commit a80c0624fbd8bd1c784b0b5b7a0fd20b09d317b9 Author: ache Date: Fri Oct 7 08:58:58 1994 +0000 Moved from ports with several enhancements diff --git a/lib/libncurses/COPYRIGHT.NEW b/lib/libncurses/COPYRIGHT.NEW new file mode 100644 index 000000000000..4a79f1df92cb --- /dev/null +++ b/lib/libncurses/COPYRIGHT.NEW @@ -0,0 +1,18 @@ +/*************************************************************************** +* COPYRIGHT NOTICE * +**************************************************************************** +* ncurses is copyright (C) 1992, 1993, 1994 * +* by Zeyd M. Ben-Halim * +* zmbenhal@netcom.com * +* * +* Permission is hereby granted to reproduce and distribute ncurses * +* by any means and for any fee, whether alone or as part of a * +* larger distribution, in source or in binary form, PROVIDED * +* this notice remains in the sources and is reproduced in any * +* documentation accompanying it or the applications linked with it. * +* Any other use of ncurses, including incorporating it in another * +* product is subject to written permission. * +* * +* ncurses comes AS IS with no warranty, implied or expressed. * +* * +***************************************************************************/ diff --git a/lib/libncurses/COPYRIGHT.OLD b/lib/libncurses/COPYRIGHT.OLD new file mode 100644 index 000000000000..4049db08fd9e --- /dev/null +++ b/lib/libncurses/COPYRIGHT.OLD @@ -0,0 +1,5 @@ + +Pavel Curtis has given up his copyright to the public domain. This mean +his ORIGINAL sources are in the public domain, not this current release. +This current release IS copyrighted, see COPYRIGHT.NEW. + diff --git a/lib/libncurses/MKkeyname.awk b/lib/libncurses/MKkeyname.awk new file mode 100644 index 000000000000..be51bc8e4281 --- /dev/null +++ b/lib/libncurses/MKkeyname.awk @@ -0,0 +1,30 @@ + +BEGIN { + print "" + print "#include " + print "#include " + print "" + print "struct kn {" + print "\tchar *name;" + print "\tint code;" + print "};" + print "" + print "struct kn key_names[] = {" +} + +{printf "\t{\"%s\", %s,},\n", $1, $2;} + +END { + print "};" + print "" + print "char *keyname(int c)" + print "{" + print "int i, size = sizeof(key_names)/sizeof(struct kn);" + print "" + print "\tfor (i = 0; i < size; i++) {" + print "\t\tif (key_names[i].code == c) return key_names[i].name;" + print "\t}" + print "\treturn NULL;" + print "}" + print "" +} diff --git a/lib/libncurses/MKkeys.awk b/lib/libncurses/MKkeys.awk new file mode 100644 index 000000000000..669c455ef547 --- /dev/null +++ b/lib/libncurses/MKkeys.awk @@ -0,0 +1 @@ +{printf "\tadd_to_try(%s, %s);\n", $1, $2;} diff --git a/lib/libncurses/Makefile b/lib/libncurses/Makefile new file mode 100644 index 000000000000..a5c2911f56eb --- /dev/null +++ b/lib/libncurses/Makefile @@ -0,0 +1,73 @@ +LIB= ncurses +INCDIR= /usr/include +CFLAGS+= -Wall -DMYTINFO -DTERMIOS -DGOOD_SELECT -DBSDTABS +SHARED_LDADD+= -lmytinfo +SRCS= lib_kernel.c lib_pad.c\ + lib_unctrl.c lib_raw.c lib_vidattr.c lib_trace.c lib_beep.c \ + lib_doupdate.c lib_refresh.c lib_initscr.c lib_newwin.c lib_addch.c \ + lib_addstr.c lib_scroll.c lib_clreol.c lib_touch.c lib_mvcur.c lib_keyname.c\ + lib_delwin.c lib_endwin.c lib_clrbot.c lib_move.c lib_printw.c \ + lib_scanw.c lib_erase.c lib_getch.c lib_options.c lib_acs.c lib_slk.c\ + lib_box.c lib_clear.c lib_delch.c lib_deleteln.c lib_insch.c \ + lib_insertln.c lib_getstr.c lib_mvwin.c lib_longname.c lib_tstp.c \ + lib_newterm.c lib_set_term.c lib_overlay.c lib_scrreg.c lib_color.c \ + lib_insstr.c lib_insdel.c lib_twait.c +CLEANFILES+= lib_keyname.c ${.CURDIR}/keys.tries + +beforedepend: ${.CURDIR}/keys.tries + +beforeinstall: + @cd ${.CURDIR}; for i in ncurses.h nterm.h unctrl.h termcap.h; do \ + cmp -s $$i ${DESTDIR}${INCDIR}/$$i || \ + $(INSTALL) $(COPY) -m 444 -o $(BINOWN) -g $(BINGRP) $$i ${DESTDIR}$(INCDIR); done + +${.CURDIR}/keys.tries: keys.list MKkeys.awk + awk -f ${.CURDIR}/MKkeys.awk ${.CURDIR}/keys.list > ${.CURDIR}/keys.tries + +# in case you don't run make depend +lib_options.o: ${.CURDIR}/keys.tries + +lib_keyname.c: keys.list MKkeyname.awk + awk -f ${.CURDIR}/MKkeyname.awk ${.CURDIR}/keys.list > lib_keyname.c + +MAN3 = curs_addch.3 \ + curs_addchst.3 \ + curs_addstr.3 \ + curs_attr.3 \ + curs_beep.3 \ + curs_bkgd.3 \ + curs_border.3 \ + curs_clear.3 \ + curs_color.3 \ + curs_delch.3 \ + curs_delln.3 \ + curs_getch.3 \ + curs_getstr.3 \ + curs_getyx.3 \ + curs_inch.3 \ + curs_inchstr.3 \ + curs_initscr.3 \ + curs_inopts.3 \ + curs_insch.3 \ + curs_insstr.3 \ + curs_instr.3 \ + curs_kernel.3 \ + curs_move.3 \ + curs_outopts.3 \ + curs_overlay.3 \ + curs_pad.3 \ + curs_printw.3 \ + curs_refresh.3 \ + curs_scanw.3 \ + curs_scr_dmp.3 \ + curs_scroll.3 \ + curs_slk.3 \ + curs_termatt.3 \ + curs_touch.3 \ + curs_util.3 \ + curs_window.3 \ + ncurses.3 + +MAN5 = term.5 terminfo.5 + +.include diff --git a/lib/libncurses/README b/lib/libncurses/README new file mode 100644 index 000000000000..ad58ccdf36a1 --- /dev/null +++ b/lib/libncurses/README @@ -0,0 +1,39 @@ +This file is intended to help people interested in working +on fixing ncurses, enhancing it, or porting it to other +platforms. + +PORTABILITY: +The file matrix is an attempt and centralizing all portability +information. The top line contains the different options, down +the leftside are the operating systems supported. If an option +is not needed then it should have an entry of NONE. Note the +use of ':' to terminate each field. If somebody knows awk better +than me, get in touch. + +OS: name of operating system +ISPOSIX: -DNONPOSIX if is missing +POSIX: -DSTRICTPOSIX if _POSIX_SOURCE turns off non-POSIX features. + -DSVR4_ACTION if like svr4 you need _POSIX_SOURCE to have sigaction +TERMINAL: -DNOTERMIOS if you don't have but have +HEADERS: -DBRAINDEAD if system headers don't declare external variables +TABS: -DBSDTABS if you don't have TABS3 but have OXTABS +OPT: -DOPT_MVCUR if you want mvcur() to cost its actions or you have a + terminal that doesn't have direct cursor addressing. +SRCDIR: the directory where the terminfo database lives +CC: ANSI C compiler +FLAGS: standard compiler flags +EXTRA: extra flags needed by individual systems + Linux: -DBROKEN_TCDRAIN tcdrain() is broken on Linux + Sun: -DSUNIOCTL conflicts with + HP-UX: -D_HPUX_SOURCE so that we get POSIX and XOPEN features. + SVR4: -DBROKEN_TIOCGETWINSZ guess what? +BASE: The directory under which headers and libraries will + be installed. +INSTALL: The name of an intelligent install program. GNU install works. + +The awk script in script.src reads matrix and generates all the Config.* +files. + +There are several problems with strict POSIX systems so extra flags +or #define's maybe needed. + diff --git a/lib/libncurses/TESTS/Makefile b/lib/libncurses/TESTS/Makefile new file mode 100644 index 000000000000..9b258df497a2 --- /dev/null +++ b/lib/libncurses/TESTS/Makefile @@ -0,0 +1,37 @@ +TESTS = test corner ensor getch ncurses bs gdc hanoi knight rain worm \ + over scroll2 battle newdemo scroll3 xmas copy firework testcurs \ + scroll + +CLEANFILES += $(TESTS) + +LIBS += -lncurses -lmytinfo + +all: $(TESTS) + +$(TESTS): + $(CC) $(CFLAGS) $(LDFLAGS) ${.CURDIR}/$@.c -o $@ $(LIBS) + +test: test.c +corner: corner.c +ensor: ensor.c +getch: getch.c +ncurses: ncurses.c +bs: bs.c +gdc: gdc.c +hanoi: hanoi.c +knight: knight.c +rain: rain.c +worm: worm.c +over: over.c +scroll2: scroll2.c +battle: battle.c +newdemo: newdemo.c +scroll3: scroll3.c +xmas: xmas.c +copy: copy.c +firework: firework.c +testcurs: testcurs.c +scroll: scroll.c + +.include "bsd.prog.mk" + diff --git a/lib/libncurses/TESTS/README b/lib/libncurses/TESTS/README new file mode 100644 index 000000000000..7f45243ff1e4 --- /dev/null +++ b/lib/libncurses/TESTS/README @@ -0,0 +1,22 @@ +The programs in this directory are designed to test your newest toy :-) +Check the sources for any further details. + +asc.c - tests the line drawing functions +attr.c - display attributes available on the terminal +bs.c - the game of battleship +battle.c - older version of battleship with different interface +caps.c - output a list of all capabilites to stderr (redirect to a file + or it will screw up the terminal) +copy.c - test overlay +gdc.c - Great Digital Clock, gives an example of usng color +getch.c - tests ketpad() and getch() +hanoi.c - the game of hanoi, also an example of using color +knight.c - the game of Knight's Tour +rain.c - rain drops are falling on my head.. +scroll.c - test scrolling region +slk.c - test soft labels +worm.c - worms run all over your screen +firework.c - multi-colored fireworks +newdemo.c - a demo from the PDCurses people +testcurs.c - a test from the PDCurses people + This will fail to link on machines that don't have vsscanf(). diff --git a/lib/libncurses/TESTS/battle.c b/lib/libncurses/TESTS/battle.c new file mode 100644 index 000000000000..e7785fccb035 --- /dev/null +++ b/lib/libncurses/TESTS/battle.c @@ -0,0 +1,705 @@ +/* + * battle.c - original author: Bruce Holloway + * mods by: Chuck A DeGaul + */ + +#include +#include +#include +#include +#include +#include + +#define OTHER 1-turn + +char numbers[] = " 0 1 2 3 4 5 6 7 8 9"; + +char carrier[] = "Aircraft Carrier"; +char battle[] = "Battleship"; +char sub[] = "Submarine"; +char destroy[] = "Destroyer"; +char ptboat[] = "PT Boat"; + +char name[40]; +char dftname[] = "Stranger"; + +struct _ships { + char *name; + char symbol; + char length; + char start; /* Coordinates - 0,0=0; 10,10=100. */ + char dir; /* Direction - 0 = right; 1 = down. */ + char hits; /* How many times has this ship been hit? (-1==sunk) */ +}; + +struct _ships plyship[] = { + { carrier,'A',5,0,0,0 }, + { battle,'B',4,0,0,0 }, + { destroy,'D',3,0,0,0 }, + { sub,'S',3,0,0,0 }, + { ptboat,'P',2,0,0,0 }, +}; + +struct _ships cpuship[] = { + { carrier,'A',5,0,0,0 }, + { battle,'B',4,0,0,0 }, + { destroy,'D',3,0,0,0 }, + { sub,'S',3,0,0,0 }, + { ptboat,'P',2,0,0,0 }, +}; + +char hits[2][100], board[2][100]; /* "Hits" board, and main board. */ + +int srchstep; +int cpuhits; +int cstart, cdir; +int plywon=0, cpuwon=0; /* How many games has each won? */ +int turn; /* 0=player, 1=computer */ +int huntoffs; /* Offset on search strategy */ + +int salvo, blitz, ask, seemiss; /* options */ + +void intro(void); +void initgame(void); +int rnd(int); +void plyplace(struct _ships *); +int getdir(void); +void placeship(struct _ships *, int, int); +int checkplace(struct _ships *, int, int); +void error(char *); +void prompt(void); +char getcoord(void); +void cpuplace(struct _ships *); +int awinna(void); +int plyturn(void); +int hitship(int); +int cputurn(void); +int playagain(void); +void uninitgame(); +int sgetc(char *); +int do_options(int, char *[]); +int scount(int); + +int +main(int argc, char **argv) +{ + do_options(argc, argv); + + intro(); + do { + initgame(); + while(awinna() == -1) { + if (!blitz) { + if (!salvo) { + if (turn) + cputurn(); + else plyturn(); + } else { + register int i; + + i = scount(turn); + while (i--) { + if (turn) + if (cputurn()) + if (awinna() != -1) + i = 0; + else + if(plyturn()) + if (awinna() != -1) + i = 0; + } + } + } else { + while((turn) ? cputurn() : plyturn()); + } + turn = OTHER; + } + } while(playagain()); + uninitgame(); + exit(0); +} + +#define PR addstr + +void +intro() +{ +char *tmpname; + + srand(time(0L)); /* Kick the random number generator */ + + signal(SIGINT,uninitgame); + if(signal(SIGQUIT,SIG_IGN) != SIG_IGN) signal(SIGQUIT,uninitgame); +#if 1 + /* for some bizzare reason, getlogin or cuserid cause havoc with the terminal */ + if ((tmpname = getlogin()) != NULL) { + strcpy(name, tmpname); + } else +#endif + strcpy(name,dftname); + name[0] = toupper(name[0]); + + initscr(); + savetty(); + nonl(); + cbreak(); + noecho(); + clear(); + mvaddstr(4,29,"Welcome to Battleship!"); + move(8,0); +PR(" \\\n"); +PR(" \\ \\ \\\n"); +PR(" \\ \\ \\ \\ \\_____________\n"); +PR(" \\ \\ \\_____________ \\ \\/ |\n"); +PR(" \\ \\/ \\ \\/ |\n"); +PR(" \\/ \\_____/ |__\n"); +PR(" ________________/ |\n"); +PR(" \\ S.S. Penguin |\n"); +PR(" \\ /\n"); +PR(" \\___________________________________________________/\n"); + mvaddstr(20,27,"Hit any key to continue..."); refresh(); + getch(); +} + +void +initgame() +{ +int i; + + clear(); + mvaddstr(0,35,"BATTLESHIP"); + mvaddstr(4,12,"Main Board"); + mvaddstr(6,0,numbers); + move(7,0); + for(i=0; i<10; ++i){ + printw("%c . . . . . . . . . . %c\n",i+'A',i+'A'); + } + mvaddstr(17,0,numbers); + mvaddstr(4,55,"Hit/Miss Board"); + mvaddstr(6,45,numbers); + for(i=0; i<10; ++i){ + mvprintw(7+i,45,"%c . . . . . . . . . . %c",i+'A',i+'A'); + } + mvaddstr(17,45,numbers); + for(turn=0; turn<2; ++turn) + for(i=0; i<100; ++i){ + hits[turn][i] = board[turn][i] = 0; + } + for(turn=0; turn<2; ++turn){ + for(i=0; i<5; ++i) + if (!turn) + plyplace(&plyship[i]); + else + cpuplace(&cpuship[i]); + } + turn = rnd(2); + cstart = cdir = -1; + cpuhits = 0; + srchstep = 3; + huntoffs = rnd(srchstep); +} + +int +rnd(int n) +{ + return(((rand() & 0x7FFF) % n)); +} + +void +plyplace(ss) +struct _ships *ss; +{ +int c, d; + + do { + prompt(); + printw("Place your %s (ex.%c%d) ? ",ss->name,rnd(10)+'A',rnd(10)); + c = getcoord(); + d = getdir(); + } while(!checkplace(ss,c,d)); + placeship(ss,c,d); +} + +int +getdir() +{ + + prompt(); + addstr("What direction (0=right, 1=down) ? "); + return(sgetc("01")-'0'); +} + +void +placeship(ss,c,d) +struct _ships *ss; +int c, d; +{ +int x, y, l, i; + + for(l=0; llength; ++l){ + i = c + l * ((d) ? 10 : 1); + board[turn][i] = ss->symbol; + x = (i % 10) * 3 + 3; + y = (i / 10) + 7; + if(!turn) mvaddch(y,x,ss->symbol); + } + ss->start = c; + ss->dir = d; + ss->hits = 0; +} + +int +checkplace(ss,c,d) +struct _ships *ss; +int c, d; +{ +int x, y, l; + + x = c%10; y = c/10; + if(((x+ss->length) > 10 && !d) || ((y+ss->length) > 10 && d==1)){ + if(!turn) + switch(rnd(3)){ + case 0: + error("Ship is hanging from the edge of the world"); + break; + case 1: + error("Try fitting it on the board"); + break; + case 2: + error("Figure I won't find it if you put it there?"); + break; + } + return(0); + } + for(l=0; llength; ++l){ + x = c + l * ((d) ? 10 : 1); + if(board[turn][x]){ + if(!turn) + switch(rnd(3)){ + case 0: + error("There's already a ship there"); + break; + case 1: + error("Collision alert! Aaaaaagh!"); + break; + case 2: + error("Er, Admiral, what about the other ship?"); + break; + } + return(0); + } + } + return(1); +} + +void +error(s) +char *s; +{ + prompt(); + beep(); + printw("%s -- hit any key to continue --",s); + refresh(); + getch(); +} + +void +prompt(){ + move(22,0); + clrtoeol(); +} + +char +getcoord() +{ +int ch, x, y; + +redo: + y = sgetc("ABCDEFGHIJ"); + do { + ch = getch(); + if (ch == 0x7F || ch == 8) { + addstr("\b \b"); + refresh(); + goto redo; + } + } while(ch < '0' || ch > '9'); + addch(x = ch); + refresh(); + return((y-'A')*10+x-'0'); +} + +void +cpuplace(ss) +struct _ships *ss; +{ +int c, d; + + do{ + c = rnd(100); + d = rnd(2); + } while(!checkplace(ss,c,d)); + placeship(ss,c,d); +} + +int +awinna() +{ +int i, j; +struct _ships *ss; + + for (i = 0; i < 2; ++i) { + ss = (i) ? cpuship : plyship; + for(j=0; j<5; ++j, ++ss) + if(ss->length != ss->hits) + break; + if(j == 5) return(OTHER); + } + return(-1); +} + +int +plyturn() +{ +int c, res; +char *m; + + prompt(); + addstr("Where do you want to shoot? "); + c = getcoord(); + if(!(res = hits[turn][c])){ + hits[turn][c] = res = (board[OTHER][c]) ? 'H' : 'M'; + mvaddch(7+c/10,48+3*(c%10),(res=='H') ? 'H' : 'o'); + if(c = hitship(c)){ + prompt(); + switch(rnd(3)){ + case 0: + m = "You sank my %s!"; + break; + case 1: + m = "I have this sinking feeling about my %s...."; + break; + case 2: + m = "Have some mercy for my %s!"; + break; + } + move(23,0); + clrtoeol(); + beep(); + printw(m,cpuship[c-1].name); refresh(); + return(awinna() == -1); + } + } + prompt(); + move(23,0); clrtoeol(); + printw("You %s.",(res=='M')?"missed":"scored a hit"); refresh(); + return(res == 'H'); +} + +int +hitship(c) +int c; +{ +struct _ships *ss; +int sym, i, j; + + ss = (turn) ? plyship : cpuship; + if (!(sym = board[OTHER][c])) return(0); + for (i = 0; i < 5; ++i, ++ss) + if (ss->symbol == sym) { + j = ss->hits; + ++j; + ss->hits = j; + if (j == ss->length) + return(i+1); + return(0); + } +} + +int +cputurn() +{ +int c, res, x, y, i, d; + +redo: + if (cstart == -1){ + if (cpuhits){ + for(i=0, c=rnd(100); i<100; ++i, c = (c+1) % 100) + if(hits[turn][c] == 'H') + break; + if(i != 100){ + cstart = c; + cdir = -1; + goto fndir; + } + } + do { + i = 0; + do{ + while(hits[turn][c=rnd(100)]); + x = c % 10; y = c / 10; + if(++i == 1000) break; + } while(((x+huntoffs) % srchstep) != (y % srchstep)); + if(i == 1000) --srchstep; + } while(i == 1000); + } + else if(cdir == -1){ +fndir: for(i=0, d=rnd(4); i++ < 4; d = (d+1) % 4){ + x = cstart%10; y = cstart/10; + switch(d){ + case 0: ++x; break; + case 1: ++y; break; + case 2: --x; break; + case 3: --y; break; + } + if(x<0 || x>9 || y<0 || y>9) continue; + if(hits[turn][c=y*10+x]) continue; + cdir = -2; + break; + } + if(i == 4){ + cstart = -1; + goto redo; + } + } + else{ + x = cstart%10; y = cstart/10; + switch(cdir){ + case 0: ++x; break; + case 1: ++y; break; + case 2: --x; break; + case 3: --y; break; + } + if(x<0 || x>9 || y<0 || y>9 || hits[turn][y*10+x]){ + cdir = (cdir+2) % 4; + for(;;){ + switch(cdir){ + case 0: ++x; break; + case 1: ++y; break; + case 2: --x; break; + case 3: --y; break; + } + if(x<0 || x>9 || y<0 || y>9){ cstart = -1; + goto redo; + } + if(!hits[turn][y*10+x]) break; + } + } + c = y*10 + x; + } + + if (!ask) { + res = (board[OTHER][c]) ? 'H' : 'M'; + move(21,0); clrtoeol(); + printw("I shoot at %c%d. I %s!",c/10+'A',c%10,(res=='H')?"hit":"miss"); + } else { + for(;;){ + prompt(); + printw("I shoot at %c%d. Do I (H)it or (M)iss? ",c/10+'A',c%10); + res = sgetc("HM"); + if((res=='H' && !board[OTHER][c]) || (res=='M' && board[OTHER][c])){ + error("You lie!"); + continue; + } + break; + } + addch(res); + } + hits[turn][c] = res; + if(res == 'H') { + ++cpuhits; + if(cstart == -1) cdir = -1; + cstart = c; + if(cdir == -2) cdir = d; + mvaddch(7+(c/10),3+3*(c%10),'*'); + if (blitz && !ask) { + refresh(); + sleep(1); + } + } + else { + if (seemiss) { + mvaddch(7+(c/10),3+3*(c%10),' '); + } else { + if(cdir == -2) cdir = -1; + } + } + if(c=hitship(c)){ + cstart = -1; + cpuhits -= plyship[c-1].length; + x = plyship[c-1].start; + d = plyship[c-1].dir; + y = plyship[c-1].length; + for(i=0; i= 10) ++i; + if(cpuwon >= 10) ++i; + mvprintw(2,(80-i)/2,"%s: %d Computer: %d",name,plywon,cpuwon); + + prompt(); + printw((awinna()) ? "Want to be humiliated again, %s? " + : "Going to give me a chance for revenge, %s? ",name); + return(sgetc("YN") == 'Y'); +} + +void +uninitgame(int sig) +{ + refresh(); + endwin(); + exit(0); +} + +int +sgetc(s) +char *s; +{ +char *s1; +int ch; + + refresh(); + for (;;) { + ch = toupper(getch()); + for (s1 = s; *s1 && ch != *s1; ++s1); + if (*s1) { + addch(ch); + refresh(); + return(ch); + } + } +} + +/* + * I should use getopts() from libc.a, but I'm leary that other UNIX + * systems might not have it, although I'd love to use it. + */ + +int +do_options(c,op) +int c; +char *op[]; +{ +register int i; + + if (c > 1) { + for (i=1; ihits == (char) -1 || sp->hits >= sp->length) { + continue; /* dead ship */ + } else { + shots++; + } + } + return(shots); +} + diff --git a/lib/libncurses/TESTS/bs.6 b/lib/libncurses/TESTS/bs.6 new file mode 100644 index 000000000000..38cfe82a9811 --- /dev/null +++ b/lib/libncurses/TESTS/bs.6 @@ -0,0 +1,42 @@ +.TH BATTLESHIPS 6 "Aug 23, 1989" +.SH NAME +bs \- battleships game +.SH SYNOPSIS +battle [ -b | -s ] [ -c ] +.SH DESCRIPTION +This program allows you to play the familiar Battleships game against the +computer on a 10x10 board. The interface is visual and largely +self-explanatory; you place your ships and pick your shots by moving the +cursor around the `sea' with the rogue/hack motion keys hjklyubn. +.PP +Note that when selecting a ship to place, you must type the capital letter +(these are, after all, capital ships). During ship placement, the `r' command +may be used to ignore the current position and randomly place your currently +selected ship. The `R' command will place all remaining ships randomly. The ^L +command (form feed, ASCII 12) will force a screen redraw). +.PP +The command-line arguments control game modes. + +.nf + -b selects a `blitz' variant + -s selects a `salvo' variant + -c permits ships to be placed adjacently +.fi + +The `blitz' variant allows a side to shoot for as long as it continues to +score hits. +.PP +The `salvo' game allows a player one shot per turn for each of his/her ships +still afloat. This puts a premium scoring hits early and knocking out some +ships and also makes much harder the situation where you face a superior force +with only your PT-boat. +.PP +Normally, ships must be separated by at least one square of open water. The +-c option disables this check and allows them to close-pack. +.PP +The algorithm the computer uses once it has found a ship to sink is provably +optimal. The dispersion criterion for the random-fire algorithm may not be. +.SH AUTHORS +Originally written by one Bruce Holloway in 1986. Salvo mode added by Chuck A. +DeGaul (cbosgd!cad). Visual user interface, `closepack' option, code rewrite +and manual page by Eric S. Raymond August 1989. diff --git a/lib/libncurses/TESTS/bs.c b/lib/libncurses/TESTS/bs.c new file mode 100644 index 000000000000..8d4183048e9f --- /dev/null +++ b/lib/libncurses/TESTS/bs.c @@ -0,0 +1,1119 @@ +/* + * bs.c - original author: Bruce Holloway + * salvo option by: Chuck A DeGaul + * with improved user interface, autoconfiguration and code cleanup + * by Eric S. Raymond + * v1.2 with color support and minor portability fixes, November 1990 + */ + +#include +#include +#include +#ifndef NONPOSIX +#include +#endif +#include +#include +#include +#include +#include + +#ifdef SYSV /* aha, must be an AT&T system... */ +#define srand(n) srand48(n) +#define rand() lrand48() +extern long lrand48(); +extern void srand48(); +#define bzero(s, n) memset((char *)(s), '\0', n) +extern char *memset(); +#endif /* SYSV */ + + +/* + * Constants for tuning the random-fire algorithm. It prefers moves that + * diagonal-stripe the board with a stripe separation of srchstep. If + * no such preferred moves are found, srchstep is decremented. + */ +#define BEGINSTEP 3 /* initial value of srchstep */ + +/* miscellaneous constants */ +#define SHIPTYPES 5 +#define OTHER (1-turn) +#define PLAYER 0 +#define COMPUTER 1 +#define MARK_HIT 'H' +#define MARK_MISS 'o' +#define CTRLC '\003' /* used as terminate command */ +#define FF '\014' /* used as redraw command */ + +/* coordinate handling */ +#define BWIDTH 10 +#define BDEPTH 10 + +/* display symbols */ +#define SHOWHIT '*' +#define SHOWSPLASH ' ' +#define IS_SHIP(c) isupper(c) + +/* how to position us on player board */ +#define PYBASE 3 +#define PXBASE 3 +#define PY(y) (PYBASE + (y)) +#define PX(x) (PXBASE + (x)*3) +#define pgoto(y, x) move(PY(y), PX(x)) + +/* how to position us on cpu board */ +#define CYBASE 3 +#define CXBASE 48 +#define CY(y) (CYBASE + (y)) +#define CX(x) (CXBASE + (x)*3) +#define cgoto(y, x) move(CY(y), CX(x)) + +#define ONBOARD(x, y) (x >= 0 && x < BWIDTH && y >= 0 && y < BDEPTH) + +/* other board locations */ +#define COLWIDTH 80 +#define PROMPTLINE 21 /* prompt line */ +#define SYBASE CYBASE + BDEPTH + 3 /* move key diagram */ +#define SXBASE 63 +#define MYBASE SYBASE - 1 /* diagram caption */ +#define MXBASE 64 +#define HYBASE SYBASE - 1 /* help area */ +#define HXBASE 0 + +/* this will need to be changed if BWIDTH changes */ +static char numbers[] = " 0 1 2 3 4 5 6 7 8 9"; + +static char carrier[] = "Aircraft Carrier"; +static char battle[] = "Battleship"; +static char sub[] = "Submarine"; +static char destroy[] = "Destroyer"; +static char ptboat[] = "PT Boat"; + +static char name[40]; +static char dftname[] = "Stranger"; + +/* direction constants */ +#define E 0 +#define SE 1 +#define S 2 +#define SW 3 +#define W 4 +#define NW 5 +#define N 6 +#define NE 7 +static int xincr[8] = {1, 1, 0, -1, -1, -1, 0, 1}; +static int yincr[8] = {0, 1, 1, 1, 0, -1, -1, -1}; + +/* current ship position and direction */ +static int curx = (BWIDTH / 2); +static int cury = (BDEPTH / 2); + +typedef struct +{ + char *name; /* name of the ship type */ + unsigned hits; /* how many times has this ship been hit? */ + char symbol; /* symbol for game purposes */ + char length; /* length of ship */ + char x, y; /* coordinates of ship start point */ + int dir; /* direction of `bow' */ + bool placed; /* has it been placed on the board? */ +} +ship_t; + +ship_t plyship[SHIPTYPES] = +{ + { carrier, 0, 'A', 5}, + { battle, 0, 'B', 4}, + { destroy, 0, 'D', 3}, + { sub, 0, 'S', 3}, + { ptboat, 0, 'P', 2}, +}; + +ship_t cpuship[SHIPTYPES] = +{ + { carrier, 0, 'A', 5}, + { battle, 0, 'B', 4}, + { destroy, 0, 'D', 3}, + { sub, 0, 'S', 3}, + { ptboat, 0, 'P', 2}, +}; + +/* "Hits" board, and main board. */ +static char hits[2][BWIDTH][BDEPTH], board[2][BWIDTH][BDEPTH]; + +static int turn; /* 0=player, 1=computer */ +static int plywon=0, cpuwon=0; /* How many games has each won? */ + +static int salvo, blitz, closepack; + +#define PR addstr + +static int rnd(int); +static int checkplace(int, ship_t *, int); +static int getcoord(int); + +static void uninitgame() +/* end the game, either normally or due to signal */ +{ + clear(); + refresh(); + resetterm(); + echo(); + endwin(); + exit(0); +} + +static void announceopts() +/* announce which game options are enabled */ +{ + if (salvo || blitz || closepack) { + printw("Playing optional game ("); + if (salvo) + printw("salvo, "); + else + printw("nosalvo, "); + if (blitz) + printw("blitz "); + else + printw("noblitz, "); + if (closepack) + printw("closepack)"); + else + printw("noclosepack)"); + } + else + printw( "Playing standard game (noblitz, nosalvo, noclosepack)"); + +} + +static void intro() +{ +char *tmpname; + + srand(time(0L)+getpid()); /* Kick the random number generator */ + + signal(SIGINT,uninitgame); + signal(SIGINT,uninitgame); + signal(SIGIOT,uninitgame); /* for assert(3) */ + if(signal(SIGQUIT,SIG_IGN) != SIG_IGN) + signal(SIGQUIT,uninitgame); + + if ((tmpname = getlogin()) != NULL) + strcpy(name,tmpname); + else + strcpy(name,dftname); + name[0] = toupper(name[0]); + + initscr(); + saveterm(); + nonl(); + cbreak(); + noecho(); + +#ifdef PENGUIN + clear(); + mvaddstr(4,29,"Welcome to Battleship!"); + move(8,0); + PR(" \\\n"); + PR(" \\ \\ \\\n"); + PR(" \\ \\ \\ \\ \\_____________\n"); + PR(" \\ \\ \\_____________ \\ \\/ |\n"); + PR(" \\ \\/ \\ \\/ |\n"); + PR(" \\/ \\_____/ |__\n"); + PR(" ________________/ |\n"); + PR(" \\ S.S. Penguin |\n"); + PR(" \\ /\n"); + PR(" \\___________________________________________________/\n"); + + mvaddstr(22,27,"Hit any key to continue..."); refresh(); + getch(); +#endif /* PENGUIN */ + + clear(); + mvaddstr(0,35,"BATTLESHIPS"); + move(PROMPTLINE + 2, 0); + announceopts(); + + mvaddstr(MYBASE, MXBASE, "Aiming keys:"); + mvaddstr(SYBASE, SXBASE, "y k u 7 8 9"); + mvaddstr(SYBASE+1, SXBASE, " \\|/ \\|/ "); + mvaddstr(SYBASE+2, SXBASE, "h-+-l 4-+-6"); + mvaddstr(SYBASE+3, SXBASE, " /|\\ /|\\ "); + mvaddstr(SYBASE+4, SXBASE, "b j n 1 2 3"); +} + +/* VARARGS1 */ +static void prompt(n, f, s) +/* print a message at the prompt line */ +int n; +char *f, *s; +{ + move(PROMPTLINE + n, 0); + clrtoeol(); + printw(f, s); + refresh(); +} + +static void error(s) +char *s; +{ + move(PROMPTLINE + 2, 0); + clrtoeol(); + if (s) { + addstr(s); + beep(); + } +} + +static void placeship(b, ss, vis) +int b; +ship_t *ss; +int vis; +{ +int l; + + for(l = 0; l < ss->length; ++l) { + int newx = ss->x + l * xincr[ss->dir]; + int newy = ss->y + l * yincr[ss->dir]; + + board[b][newx][newy] = ss->symbol; + if (vis) { + pgoto(newy, newx); + addch((chtype)ss->symbol); + } + } + ss->hits = 0; +} + +static void randomplace(b, ss) +/* generate a valid random ship placement into px,py */ +int b; +ship_t *ss; +{ +register int bwidth = BWIDTH - ss->length; +register int bdepth = BDEPTH - ss->length; + + do { + ss->y = rnd(bdepth); + ss->x = rnd(bwidth); + ss->dir = rnd(2) ? E : S; + } while + (!checkplace(b, ss, FALSE)); +} + +static void initgame() +{ +int i, j, unplaced; +ship_t *ss; + +#ifdef A_COLOR + start_color(); + + init_pair(COLOR_BLACK, COLOR_BLACK, COLOR_BLACK); + init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK); + init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK); + init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK); + init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK); + init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK); + init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK); + init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK); +#endif /* A_COLOR */ + + bzero(board, sizeof(char) * BWIDTH * BDEPTH * 2); + bzero(hits, sizeof(char) * BWIDTH * BDEPTH * 2); + for (i = 0; i < SHIPTYPES; i++) { + ss = cpuship + i; + ss->x = ss->y = ss->dir = ss->hits = ss->placed = 0; + ss = plyship + i; + ss->x = ss->y = ss->dir = ss->hits = ss->placed = 0; + } + + /* draw empty boards */ + mvaddstr(PYBASE - 2, PXBASE + 5, "Main Board"); + mvaddstr(PYBASE - 1, PXBASE - 3,numbers); + for(i=0; i < BDEPTH; ++i) { + mvaddch(PYBASE + i, PXBASE - 3, i + 'A'); +#ifdef A_COLOR + if (has_colors()) + attron(COLOR_PAIR(COLOR_BLUE)); +#endif /* A_COLOR */ + addch(' '); + for (j = 0; j < BWIDTH; j++) + addstr(" . "); +#ifdef A_COLOR + attrset(0); +#endif /* A_COLOR */ + addch(' '); + addch(i + 'A'); + } + mvaddstr(PYBASE + BDEPTH, PXBASE - 3,numbers); + mvaddstr(CYBASE - 2, CXBASE + 7,"Hit/Miss Board"); + mvaddstr(CYBASE - 1, CXBASE - 3, numbers); + for(i=0; i < BDEPTH; ++i) { + mvaddch(CYBASE + i, CXBASE - 3, i + 'A'); +#ifdef A_COLOR + if (has_colors()) + attron(COLOR_PAIR(COLOR_BLUE)); +#endif /* A_COLOR */ + addch(' '); + for (j = 0; j < BWIDTH; j++) + addstr(" . "); +#ifdef A_COLOR + attrset(0); +#endif /* A_COLOR */ + addch(' '); + addch(i + 'A'); + } + mvaddstr(CYBASE + BDEPTH,CXBASE - 3,numbers); + + mvprintw(HYBASE, HXBASE, + "To position your ships: move the cursor to a spot, then"); + mvprintw(HYBASE+1,HXBASE, + "type the first letter of a ship type to select it, then"); + mvprintw(HYBASE+2,HXBASE, + "type a direction ([hjkl] or [4862]), indicating how the"); + mvprintw(HYBASE+3,HXBASE, + "ship should be pointed. You may also type a ship letter"); + mvprintw(HYBASE+4,HXBASE, + "followed by `r' to position it randomly, or type `R' to"); + mvprintw(HYBASE+5,HXBASE, + "place all remaining ships randomly."); + + /* have the computer place ships */ + for(ss = cpuship; ss < cpuship + SHIPTYPES; ss++) { + randomplace(COMPUTER, ss); + placeship(COMPUTER, ss, FALSE); + } + + ss = (ship_t *)NULL; + do { + char c, docked[SHIPTYPES + 2], *cp = docked; + + /* figure which ships still wait to be placed */ + *cp++ = 'R'; + for (i = 0; i < SHIPTYPES; i++) + if (!plyship[i].placed) + *cp++ = plyship[i].symbol; + *cp = '\0'; + + /* get a command letter */ + prompt(1, "Type one of [%s] to pick a ship.", docked+1); + do { + c = getcoord(PLAYER); + } while + (!strchr(docked, c)); + + if (c == 'R') + ungetch('R'); + else + { + /* map that into the corresponding symbol */ + for (ss = plyship; ss < plyship + SHIPTYPES; ss++) + if (ss->symbol == c) + break; + + prompt(1, "Type one of [hjklrR] to place your %s.", ss->name); + pgoto(cury, curx); + } + + do { + c = getch(); + } while + (!strchr("hjklrR", c) || c == FF); + + if (c == FF) { + clearok(stdscr, TRUE); + refresh(); + } else if (c == 'r') { + prompt(1, "Random-placing your %s", ss->name); + randomplace(PLAYER, ss); + placeship(PLAYER, ss, TRUE); + error((char *)NULL); + ss->placed = TRUE; + } else if (c == 'R') { + prompt(1, "Placing the rest of your fleet at random..."); + for (ss = plyship; ss < plyship + SHIPTYPES; ss++) + if (!ss->placed) { + randomplace(PLAYER, ss); + placeship(PLAYER, ss, TRUE); + ss->placed = TRUE; + } + error((char *)NULL); + } else if (strchr("hjkl8462", c)) { + ss->x = curx; + ss->y = cury; + + switch(c) { + case 'k': case '8': ss->dir = N; break; + case 'j': case '2': ss->dir = S; break; + case 'h': case '4': ss->dir = W; break; + case 'l': case '6': ss->dir = E; break; + } + + if (checkplace(PLAYER, ss, TRUE)) { + placeship(PLAYER, ss, TRUE); + error((char *)NULL); + ss->placed = TRUE; + } + } + + for (unplaced = i = 0; i < SHIPTYPES; i++) + unplaced += !plyship[i].placed; + } while + (unplaced); + + turn = rnd(2); + + mvprintw(HYBASE, HXBASE, + "To fire, move the cursor to your chosen aiming point "); + mvprintw(HYBASE+1, HXBASE, + "and strike any key other than a motion key. "); + mvprintw(HYBASE+2, HXBASE, + " "); + mvprintw(HYBASE+3, HXBASE, + " "); + mvprintw(HYBASE+4, HXBASE, + " "); + mvprintw(HYBASE+5, HXBASE, + " "); + + prompt(0, "Press any key to start..."); + getch(); +} + +static int rnd(n) +int n; +{ + return(((rand() & 0x7FFF) % n)); +} + +static int getcoord(atcpu) +int atcpu; +{ +int ny, nx, c; + + if (atcpu) + cgoto(cury,curx); + else + pgoto(cury, curx); + refresh(); + for (;;) { + if (atcpu) { + mvprintw(CYBASE + BDEPTH+1, CXBASE+11, "(%d, %c)", curx, 'A'+cury); + cgoto(cury, curx); + } else { + mvprintw(PYBASE + BDEPTH+1, PXBASE+11, "(%d, %c)", curx, 'A'+cury); + pgoto(cury, curx); + } + + switch(c = getch()) { + case 'k': case '8': ny = cury+BDEPTH-1; nx = curx; break; + case 'j': case '2': ny = cury+1; nx = curx; break; + case 'h': case '4': ny = cury; nx = curx+BWIDTH-1; break; + case 'l': case '6': ny = cury; nx = curx+1; break; + case 'y': case '7': ny = cury+BDEPTH-1; nx = curx+BWIDTH-1; break; + case 'b': case '1': ny = cury+1; nx = curx+BWIDTH-1; break; + case 'u': case '9': ny = cury+BDEPTH-1; nx = curx+1; break; + case 'n': case '3': ny = cury+1; nx = curx+1; break; + case FF: + nx = curx; ny = cury; + clearok(stdscr, TRUE); + refresh(); + break; + default: + if (atcpu) + mvaddstr(CYBASE + BDEPTH + 1, CXBASE + 11, " "); + else + mvaddstr(PYBASE + BDEPTH + 1, PXBASE + 11, " "); + return(c); + } + + curx = nx % BWIDTH; + cury = ny % BDEPTH; + } +} + +static int collidecheck(b, y, x) +/* is this location on the selected zboard adjacent to a ship? */ +int b; +int y, x; +{ +int collide; + + /* anything on the square */ + if ((collide = IS_SHIP(board[b][x][y])) != 0) + return(collide); + + /* anything on the neighbors */ + if (!closepack) { + int i; + + for (i = 0; i < 8; i++) { + int xend, yend; + + yend = y + yincr[i]; + xend = x + xincr[i]; + if (ONBOARD(xend, yend)) + collide += IS_SHIP(board[b][xend][yend]); + } + } + return(collide); +} + +static int checkplace(b, ss, vis) +int b; +ship_t *ss; +int vis; +{ + int l, xend, yend; + + /* first, check for board edges */ + xend = ss->x + ss->length * xincr[ss->dir]; + yend = ss->y + ss->length * yincr[ss->dir]; + if (!ONBOARD(xend, yend)) { + if(vis) + switch(rnd(3)) { + case 0: + error("Ship is hanging from the edge of the world"); + break; + case 1: + error("Try fitting it on the board"); + break; + case 2: + error("Figure I won't find it if you put it there?"); + break; + } + return(0); + } + + for(l = 0; l < ss->length; ++l) { + if (collidecheck(b, ss->y+l*yincr[ss->dir], ss->x+l*xincr[ss->dir])) { + if (vis) + switch(rnd(3)) { + case 0: + error("There's already a ship there"); + break; + case 1: + error("Collision alert! Aaaaaagh!"); + break; + case 2: + error("Er, Admiral, what about the other ship?"); + break; + } + return(0); + } + } + return(1); +} + +static int awinna() +{ +int i, j; +ship_t *ss; + + for (i = 0; i < 2; ++i) { + ss = (i) ? cpuship : plyship; + for (j = 0; j < SHIPTYPES; ++j, ++ss) + if (ss->length > ss->hits) + break; + if (j == SHIPTYPES) + return(OTHER); + } + return(-1); +} + +static ship_t *hitship(x, y) +/* register a hit on the targeted ship */ +int x, y; +{ + ship_t *sb, *ss; + char sym; + int oldx, oldy; + + getyx(stdscr, oldy, oldx); + sb = (turn) ? plyship : cpuship; + if(!(sym = board[OTHER][x][y])) + return((ship_t *)NULL); + for(ss = sb; ss < sb + SHIPTYPES; ++ss) + if(ss->symbol == sym) + { + if (++ss->hits < ss->length) /* still afloat? */ + return((ship_t *)NULL); + else /* sunk! */ + { + int i, j; + + if (!closepack) + for (j = -1; j <= 1; j++) + { + int bx = ss->x + j * xincr[(ss->dir + 2) % 8]; + int by = ss->y + j * yincr[(ss->dir + 2) % 8]; + + for (i = -1; i <= ss->length; ++i) + { + int x, y; + + x = bx + i * xincr[ss->dir]; + y = by + i * yincr[ss->dir]; + if (ONBOARD(x, y)) + { + hits[turn][x][y] = MARK_MISS; + if (turn % 2 == PLAYER) + { + cgoto(y, x); +#ifdef A_COLOR + if (has_colors()) + attron(COLOR_PAIR(COLOR_GREEN)); +#endif /* A_COLOR */ + addch(MARK_MISS); +#ifdef A_COLOR + attrset(0); +#endif /* A_COLOR */ + } + } + } + } + + for (i = 0; i < ss->length; ++i) + { + int x = ss->x + i * xincr[ss->dir]; + int y = ss->y + i * yincr[ss->dir]; + + hits[turn][x][y] = ss->symbol; + if (turn % 2 == PLAYER) + { + cgoto(y, x); + addch(ss->symbol); + } + } + + move(oldy, oldx); + return(ss); + } + } + move(oldy, oldx); + return((ship_t *)NULL); +} + +static int plyturn() +{ +ship_t *ss; +bool hit; +char *m; + + prompt(1, "Where do you want to shoot? "); + for (;;) { + getcoord(COMPUTER); + if (hits[PLAYER][curx][cury]) { + prompt(1, "You shelled this spot already! Try again."); + beep(); + } else + break; + } + hit = IS_SHIP(board[COMPUTER][curx][cury]); + hits[PLAYER][curx][cury] = hit ? MARK_HIT : MARK_MISS; + cgoto(cury, curx); +#ifdef A_COLOR + if (has_colors()) + if (hit) + attron(COLOR_PAIR(COLOR_RED)); + else + attron(COLOR_PAIR(COLOR_GREEN)); +#endif /* A_COLOR */ + addch((chtype)hits[PLAYER][curx][cury]); +#ifdef A_COLOR + attrset(0); +#endif /* A_COLOR */ + + prompt(1, "You %s.", hit ? "scored a hit" : "missed"); + if(hit && (ss = hitship(curx, cury))) { + switch(rnd(5)) { + case 0: + m = " You sank my %s!"; + break; + case 1: + m = " I have this sinking feeling about my %s...."; + break; + case 2: + m = " My %s has gone to Davy Jones's locker!"; + break; + case 3: + m = " Glub, glub -- my %s is headed for the bottom!"; + break; + case 4: + m = " You'll pick up survivors from my my %s, I hope...!"; + break; + } + printw(m, ss->name); + beep(); + return(awinna() == -1); + } + return(hit); +} + +static int sgetc(s) +char *s; +{ +char *s1; +int ch; + + refresh(); + for(;;) { + ch = getch(); + if (islower(ch)) + ch = toupper(ch); + if (ch == CTRLC) + uninitgame(); + for (s1=s; *s1 && ch != *s1; ++s1) + continue; + if (*s1) { + addch((chtype)ch); + refresh(); + return(ch); + } + } +} + + +static void randomfire(px, py) +/* random-fire routine -- implements simple diagonal-striping strategy */ +int *px, *py; +{ +static int turncount = 0; +static int srchstep = BEGINSTEP; +static int huntoffs; /* Offset on search strategy */ +int ypossible[BWIDTH * BDEPTH], xpossible[BWIDTH * BDEPTH], nposs; +int ypreferred[BWIDTH * BDEPTH], xpreferred[BWIDTH * BDEPTH], npref; +int x, y, i; + + if (turncount++ == 0) + huntoffs = rnd(srchstep); + + /* first, list all possible moves */ + nposs = npref = 0; + for (x = 0; x < BWIDTH; x++) + for (y = 0; y < BDEPTH; y++) + if (!hits[COMPUTER][x][y]) { + xpossible[nposs] = x; + ypossible[nposs] = y; + nposs++; + if (((x+huntoffs) % srchstep) != (y % srchstep)) { + xpreferred[npref] = x; + ypreferred[npref] = y; + npref++; + } + } + + if (npref) { + i = rnd(npref); + + *px = xpreferred[i]; + *py = ypreferred[i]; + } else if (nposs) { + i = rnd(nposs); + + *px = xpossible[i]; + *py = ypossible[i]; + + if (srchstep > 1) + --srchstep; + } else { + error("No moves possible?? Help!"); + exit(1); + /*NOTREACHED*/ + } +} + +#define S_MISS 0 +#define S_HIT 1 +#define S_SUNK -1 + +static bool cpufire(x, y) +/* fire away at given location */ +int x, y; +{ +bool hit, sunk; +ship_t *ss; + + hits[COMPUTER][x][y] = (hit = (board[PLAYER][x][y])) ? MARK_HIT : MARK_MISS; + mvprintw(PROMPTLINE, 0, + "I shoot at %c%d. I %s!", y + 'A', x, hit ? "hit" : "miss"); + if ((sunk = (hit && (ss = hitship(x, y)))) != 0) + printw(" I've sunk your %s", ss->name); + clrtoeol(); + + pgoto(y, x); +#ifdef A_COLOR + if (has_colors()) + if (hit) + attron(COLOR_PAIR(COLOR_RED)); + else + attron(COLOR_PAIR(COLOR_GREEN)); +#endif /* A_COLOR */ + addch((chtype)(hit ? SHOWHIT : SHOWSPLASH)); +#ifdef A_COLOR + attrset(0); +#endif /* A_COLOR */ + + return(hit ? (sunk ? S_SUNK : S_HIT) : S_MISS); +} + +/* + * This code implements a fairly irregular FSM, so please forgive the rampant + * unstructuredness below. The five labels are states which need to be held + * between computer turns. + */ +static bool cputurn() +{ +#define POSSIBLE(x, y) (ONBOARD(x, y) && !hits[COMPUTER][x][y]) +#define RANDOM_FIRE 0 +#define RANDOM_HIT 1 +#define HUNT_DIRECT 2 +#define FIRST_PASS 3 +#define REVERSE_JUMP 4 +#define SECOND_PASS 5 + static int next = RANDOM_FIRE; + static bool used[4]; + static ship_t ts; + int navail, x, y, d, n, hit = S_MISS; + + switch(next) { + case RANDOM_FIRE: /* last shot was random and missed */ + refire: + randomfire(&x, &y); + if (!(hit = cpufire(x, y))) + next = RANDOM_FIRE; + else { + ts.x = x; ts.y = y; + ts.hits = 1; + next = (hit == S_SUNK) ? RANDOM_FIRE : RANDOM_HIT; + } + break; + + case RANDOM_HIT: /* last shot was random and hit */ + used[E/2] = used[S/2] = used[W/2] = used[N/2] = FALSE; + /* FALLTHROUGH */ + + case HUNT_DIRECT: /* last shot hit, we're looking for ship's long axis */ + for (d = navail = 0; d < 4; d++) { + x = ts.x + xincr[d*2]; y = ts.y + yincr[d*2]; + if (!used[d] && POSSIBLE(x, y)) + navail++; + else + used[d] = TRUE; + } + if (navail == 0) /* no valid places for shots adjacent... */ + goto refire; /* ...so we must random-fire */ + else { + for (d = 0, n = rnd(navail) + 1; n; n--) + while (used[d]) + d++; + + assert(d <= 4); + + used[d] = FALSE; + x = ts.x + xincr[d*2]; + y = ts.y + yincr[d*2]; + + assert(POSSIBLE(x, y)); + + if (!(hit = cpufire(x, y))) + next = HUNT_DIRECT; + else + { + ts.x = x; ts.y = y; ts.dir = d*2; ts.hits++; + next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS; + } + } + break; + + case FIRST_PASS: /* we have a start and a direction now */ + x = ts.x + xincr[ts.dir]; + y = ts.y + yincr[ts.dir]; + if (POSSIBLE(x, y) && (hit = cpufire(x, y))) { + ts.x = x; ts.y = y; ts.hits++; + next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS; + } + else + next = REVERSE_JUMP; + break; + + case REVERSE_JUMP: /* nail down the ship's other end */ + d = ts.dir + 4; + x = ts.x + ts.hits * xincr[d]; + y = ts.y + ts.hits * yincr[d]; + if (POSSIBLE(x, y) && (hit = cpufire(x, y))) { + ts.x = x; ts.y = y; ts.dir = d; ts.hits++; + next = (hit == S_SUNK) ? RANDOM_FIRE : SECOND_PASS; + } + else + next = RANDOM_FIRE; + break; + + case SECOND_PASS: /* kill squares not caught on first pass */ + x = ts.x + xincr[ts.dir]; + y = ts.y + yincr[ts.dir]; + if (POSSIBLE(x, y) && (hit = cpufire(x, y))) { + ts.x = x; ts.y = y; ts.hits++; + next = (hit == S_SUNK) ? RANDOM_FIRE: SECOND_PASS; + break; + } else + next = RANDOM_FIRE; + break; + } + + /* check for continuation and/or winner */ + if (salvo) { + refresh(); + sleep(1); + } + if (awinna() != -1) + return(FALSE); + +#ifdef DEBUG + mvprintw(PROMPTLINE + 2, 0, "New state %d, x=%d, y=%d, d=%d", + next, x, y, d); +#endif /* DEBUG */ + return(hit); +} + +int +playagain() +{ +int j; +ship_t *ss; + + for (ss = cpuship; ss < cpuship + SHIPTYPES; ss++) + for(j = 0; j < ss->length; j++) { + cgoto(ss->y + j * yincr[ss->dir], ss->x + j * xincr[ss->dir]); + addch((chtype)ss->symbol); + } + + if (awinna()) + ++cpuwon; + else + ++plywon; + j = 18 + strlen(name); + if(plywon >= 10) + ++j; + if(cpuwon >= 10) + ++j; + mvprintw(1,(COLWIDTH-j)/2, "%s: %d Computer: %d",name,plywon,cpuwon); + + prompt(2, (awinna()) ? "Want to be humiliated again, %s [yn]? " + : "Going to give me a chance for revenge, %s [yn]? ",name); + return(sgetc("YN") == 'Y'); +} + +static void do_options(c,op) +int c; +char *op[]; +{ +register int i; + + if (c > 1) { + for (i=1; ihits >= sp->length) + continue; /* dead ship */ + else + shots++; + } + return(shots); +} + +int +main(argc, argv) +int argc; +char *argv[]; +{ + do_options(argc, argv); + + intro(); + do { + initgame(); + while(awinna() == -1) { + if (!blitz) { + if (!salvo) { + if(turn) + cputurn(); + else + plyturn(); + } else { + register int i; + + i = scount(turn); + while (i--) { + if (turn) { + if (cputurn() && awinna() != -1) + i = 0; + } else { + if (plyturn() && awinna() != -1) + i = 0; + } + } + } + } else + while(turn ? cputurn() : plyturn()) + continue; + turn = OTHER; + } + } while (playagain()); + uninitgame(); + /*NOTREACHED*/ +} + +/* bs.c ends here */ diff --git a/lib/libncurses/TESTS/copy.c b/lib/libncurses/TESTS/copy.c new file mode 100644 index 000000000000..6ded258b90d2 --- /dev/null +++ b/lib/libncurses/TESTS/copy.c @@ -0,0 +1,39 @@ +#include + +main() +{ +WINDOW *win1, *win2; +int h, i; + + initscr(); + cbreak(); + noecho(); + win1 = newwin(20, 50, 0, 20); + for (h = 0; h < 20; h++) + for (i = 0; i < 50; i++) + mvwaddch(win1, h, i, 'X'); + wrefresh(win1); + getch(); + + win2 = newwin(20, 50, 3, 30); + for (h = 0; h < 20; h++) + for (i = 0; i < 50; i++) + mvwaddch(win2, h, i, 'Y'); + wnoutrefresh(win1); + wnoutrefresh(win2); + doupdate(); + getch(); + + /* now, remove window 2 and restore the contents of window 1 */ + i = copywin(win1, win2, 5, 10, 0, 0, 14, 39, 0); + wnoutrefresh(win1); + wnoutrefresh(win2); + printw("copywin returns %d\n", i); + wnoutrefresh(stdscr); + doupdate(); + + getch(); + + endwin(); +} + diff --git a/lib/libncurses/TESTS/corner.c b/lib/libncurses/TESTS/corner.c new file mode 100644 index 000000000000..2ab38a982af8 --- /dev/null +++ b/lib/libncurses/TESTS/corner.c @@ -0,0 +1,16 @@ +#include + +int main() +{ +int i, j; + + initscr(); + + for (i = 0; i < LINES; i++) { + j = mvaddch(i, COLS - 1, 'A' + i); + } + refresh(); + endwin(); + exit(0); +} + diff --git a/lib/libncurses/TESTS/ensor.c b/lib/libncurses/TESTS/ensor.c new file mode 100644 index 000000000000..7ace03899db9 --- /dev/null +++ b/lib/libncurses/TESTS/ensor.c @@ -0,0 +1,52 @@ +#include + +main() +{ + int i; + WINDOW *win; + + initscr(); + noecho(); + nonl(); + cbreak(); + + scrollok(stdscr, TRUE); + + for (i=0; i<25; i++) + printw("This is in the background, this should be left alone!\n"); + + refresh(); + win=newwin(10,50,6,20); + scrollok(win,TRUE); + wmove(win,0,0); + whline(win,0,49); + wmove(win,9,0); + whline(win,0,49); + wrefresh(win); + wattrset(win,A_STANDOUT); + mvwprintw(win, 0, 14, " Scrolling Demo! "); + mvwprintw(win, 9, 14, " Scrolling Demo! "); + wattroff(win,A_STANDOUT); + wsetscrreg(win, 1,8); + + mvwprintw(win, 0, 5, " DOWN "); + wmove(win,1,0); + wrefresh(win); + + getch(); + for (i=0; i<25; i++){ wprintw(win, "This is window line test (%d).\n", i); + if (i%2) wattrset(win,A_BOLD); else wattroff(win,A_BOLD); + wrefresh(win); } + + mvwprintw(win, 0, 5, " UP "); + wrefresh(win); + getch(); + for (i=0; i<25; i++) { wmove(win,1,0); winsertln(win); + if (i%2) wattrset(win,A_BOLD); else wattroff(win,A_BOLD); + wprintw(win, "Scrolling backwards! (%d)\n", i); wrefresh(win); } + + mvwprintw(win, 0, 5, " DONE "); wrefresh(win); + + endwin(); +} + diff --git a/lib/libncurses/TESTS/firework.c b/lib/libncurses/TESTS/firework.c new file mode 100644 index 000000000000..b4975849b593 --- /dev/null +++ b/lib/libncurses/TESTS/firework.c @@ -0,0 +1,113 @@ +#include +#include +#include +#include +#include +#include + +void explode(); + +int main() +{ +int start,end,row,diff,flag,direction,seed; + + initscr(); + if (has_colors()) + start_color(); + seed = time((time_t *)0); + srand(seed); + cbreak(); + for (;;) { + do { + start = rand() % (COLS -3); + end = rand() % (COLS - 3); + start = (start < 2) ? 2 : start; + end = (end < 2) ? 2 : end; + direction = (start > end) ? -1 : 1; + diff = abs(start-end); + } while (diff<2 || diff>=LINES-2); + attrset(A_NORMAL); + for (row=0;row 8) + attr |= A_BOLD; + return(attr); +} diff --git a/lib/libncurses/TESTS/gdc.6 b/lib/libncurses/TESTS/gdc.6 new file mode 100644 index 000000000000..7fa60de9edf8 --- /dev/null +++ b/lib/libncurses/TESTS/gdc.6 @@ -0,0 +1,22 @@ +.TH GDC 6 +.SH NAME +gdc \- grand digital clock (curses) +.SH SYNOPSIS +.B gdc +[-s] [ +.I n +] +.SH DESCRIPTION +.I Gdc +runs a digital clock made of reverse-video blanks on a curses +compatible VDU screen. With an optional numeric argument +.I n +it stops after +.I n +seconds (default never). +The optional +.B -s +flag makes digits scroll as they change. In this curses mode implementation, +the scrolling option has trouble keeping up. +.SH AUTHOR +Amos Shapir, modified for curses by John Lupien. diff --git a/lib/libncurses/TESTS/gdc.c b/lib/libncurses/TESTS/gdc.c new file mode 100644 index 000000000000..7f80d93b497a --- /dev/null +++ b/lib/libncurses/TESTS/gdc.c @@ -0,0 +1,174 @@ +/* + * Grand digital clock for curses compatible terminals + * Usage: gdc [-s] [n] -- run for n seconds (default infinity) + * Flags: -s: scroll + * + * modified 10-18-89 for curses (jrl) + * 10-18-89 added signal handling + */ + +#include +#include +#include +#include +#ifndef NONPOSIX +#include +#endif + +/* it won't be */ +long now; /* yeah! */ +struct tm *tm; + +short disp[11] = { + 075557, 011111, 071747, 071717, 055711, + 074717, 074757, 071111, 075757, 075717, 002020 +}; +long old[6], next[6], new[6], mask; +char scrol; + +int sigtermed=0; + +int hascolor = 0; + +void set(int, int); +void standt(int); +void movto(int, int); + +void sighndl(signo) +int signo; +{ + signal(signo, sighndl); + sigtermed=signo; +} + +int +main(argc, argv) +int argc; +char **argv; +{ +long t, a; +int i, j, s, k; +int n = 0; + + signal(SIGINT,sighndl); + signal(SIGTERM,sighndl); + signal(SIGKILL,sighndl); + + initscr(); + cbreak(); + noecho(); + + hascolor = has_colors(); + + if(hascolor) { + start_color(); + init_pair(1, COLOR_BLACK, COLOR_RED); + init_pair(2, COLOR_RED, COLOR_BLACK); + attrset(COLOR_PAIR(2)); + } + + clear(); + refresh(); + while(--argc > 0) { + if(**++argv == '-') + scrol = 1; + else + n = atoi(*argv); + } + do { + mask = 0; + time(&now); + tm = localtime(&now); + set(tm->tm_sec%10, 0); + set(tm->tm_sec/10, 4); + set(tm->tm_min%10, 10); + set(tm->tm_min/10, 14); + set(tm->tm_hour%10, 20); + set(tm->tm_hour/10, 24); + set(10, 7); + set(10, 17); + for(k=0; k<6; k++) { + if(scrol) { + for(i=0; i<5; i++) + new[i] = (new[i]&~mask) | (new[i+1]&mask); + new[5] = (new[5]&~mask) | (next[k]&mask); + } else + new[k] = (new[k]&~mask) | (next[k]&mask); + next[k] = 0; + for(s=1; s>=0; s--) { + standt(s); + for(i=0; i<6; i++) { + if((a = (new[i]^old[i])&(s ? new : old)[i]) != 0) { + for(j=0,t=1<<26; t; t>>=1,j++) { + if(a&t) { + if(!(a&(t<<1))) { + movto(i, 2*j); + } + addstr(" "); + } + } + } + if(!s) { + old[i] = new[i]; + } + } + if(!s) { + refresh(); + } + } + } + movto(6, 0); + refresh(); + sleep(1); + if (sigtermed) { + standend(); + clear(); + refresh(); + endwin(); + fprintf(stderr, "gdc terminated by signal %d\n", sigtermed); + exit(1); + } + } while(--n); + standend(); + clear(); + refresh(); + endwin(); + return(0); +} + +void +set(int t, int n) +{ +int i, m; + + m = 7<>(4-i)*3)&07)< + +main() + { + int c,i; + initscr(); + cbreak(); + noecho(); +#if 1 + wtimeout(stdscr,1000); +#endif + scrollok(stdscr,TRUE); + for (c='A';c<='Z';c++) + for (i=0;i<25;i++) + { + move(i,i); + addch(c); + refresh(); + } + move (0,0); + while ((c=wgetch(stdscr))!='A') + { + if (c == EOF) printw(">>wait for keypress<<"); + else printw(">>%c<<\n",c); + refresh(); + } + endwin(); + } + diff --git a/lib/libncurses/TESTS/hanoi.c b/lib/libncurses/TESTS/hanoi.c new file mode 100644 index 000000000000..422d5dae66ee --- /dev/null +++ b/lib/libncurses/TESTS/hanoi.c @@ -0,0 +1,267 @@ +/* + * Name: Towers of Hanoi. + * + * Desc: + * This is a playable copy of towers of hanoi. + * Its sole purpose is to demonstrate my Amiga Curses package. + * This program should compile on any system that has Curses. + * 'hanoi' will give a manual game with 7 playing pieces. + * 'hanoi n' will give a manual game with n playing pieces. + * 'hanoi n a' will give an auto solved game with n playing pieces. + * + * Author: Simon J Raybould (sie@fulcrum.bt.co.uk). + * + * Date: 05.Nov.90 + * + */ + +#include + +#define NPEGS 3 /* This is not configurable !! */ +#define MINTILES 3 +#define MAXTILES 9 +#define DEFAULTTILES 7 +#define TOPLINE 6 +#define BASELINE 16 +#define STATUSLINE (LINES-3) +#define LEFTPEG 19 +#define MIDPEG 39 +#define RIGHTPEG 59 + +#define LENTOIND(x) (((x)-1)/2-1) +#define OTHER(a,b) (3-((a)+(b))) + +struct Peg { + int Length[MAXTILES]; + int Count; +}; + +struct Peg Pegs[NPEGS]; +int PegPos[] = { LEFTPEG, MIDPEG, RIGHTPEG }; +int TileColour[] = { + COLOR_GREEN, /* Length 3 */ + COLOR_MAGENTA, /* Length 5 */ + COLOR_RED, /* Length 7 */ + COLOR_BLUE, /* Length 9 */ + COLOR_CYAN, /* Length 11 */ + COLOR_YELLOW, /* Length 13 */ + COLOR_GREEN, /* Length 15 */ + COLOR_MAGENTA, /* Length 17 */ + COLOR_RED, /* Length 19 */ +}; +int NMoves = 0; + +void InitTiles(), DisplayTiles(), MakeMove(), AutoMove(), Usage(); + +int +main(int argc, char **argv) +{ +int NTiles, FromCol, ToCol; +unsigned char AutoFlag = 0; + + switch(argc) { + case 1: + NTiles = DEFAULTTILES; + break; + case 2: + NTiles = atoi(argv[1]); + if (NTiles > MAXTILES || NTiles < MINTILES) { + fprintf(stderr, "Range %d to %d\n", MINTILES, MAXTILES); + exit(1); + } + break; + case 3: + if (strcmp(argv[2], "a")) { + Usage(); + exit(1); + } + NTiles = atoi(argv[1]); + if (NTiles > MAXTILES || NTiles < MINTILES) { + fprintf(stderr, "Range %d to %d\n", MINTILES, MAXTILES); + exit(1); + } + AutoFlag = TRUE; + break; + default: + Usage(); + exit(1); + } + initscr(); + if (!has_colors()) { + puts("terminal doesn't support color."); + exit(1); + } + traceon(); + start_color(); + { + int i; + for (i = 0; i < 9; i++) + init_pair(i+1, COLOR_BLACK, TileColour[i]); + } + cbreak(); + if (LINES < 24) { + fprintf(stderr, "Min screen length 24 lines\n"); + endwin(); + exit(1); + } + if(AutoFlag) + leaveok(stdscr, TRUE); /* Attempt to remove cursor */ + InitTiles(NTiles); + DisplayTiles(); + if(AutoFlag) { + do { + noecho(); + AutoMove(0, 2, NTiles); + } while(!Solved(NTiles)); + sleep(2); + } else { + for(;;) { + if(GetMove(&FromCol, &ToCol)) + break; + if(InvalidMove(FromCol, ToCol)) { + mvaddstr(STATUSLINE, 0, "Invalid Move !!"); + refresh(); + beep(); + continue; + } + MakeMove(FromCol, ToCol); + if(Solved(NTiles)) { + mvprintw(STATUSLINE, 0, "Well Done !! You did it in %d moves", NMoves); + refresh(); + sleep(5); + break; + } + } + } + endwin(); +} + +int +InvalidMove(int From, int To) +{ + if(From == To) + return TRUE; + if(!Pegs[From].Count) + return TRUE; + if(Pegs[To].Count && + Pegs[From].Length[Pegs[From].Count-1] > + Pegs[To].Length[Pegs[To].Count-1]) + return TRUE; + return FALSE; +} + +void +InitTiles(int NTiles) +{ +int Size, SlotNo; + + for(Size=NTiles*2+1, SlotNo=0; Size>=3; Size-=2) + Pegs[0].Length[SlotNo++] = Size; + + Pegs[0].Count = NTiles; + Pegs[1].Count = 0; + Pegs[2].Count = 0; +} + +#define gc() {noecho();getch();echo();} + +void +DisplayTiles() +{ + int Line, Peg, SlotNo; + char TileBuf[BUFSIZ]; + + erase(); + mvaddstr(1, 24, "T O W E R S O F H A N O I"); + mvaddstr(3, 34, "SJR 1990"); + mvprintw(19, 5, "Moves : %d", NMoves); + standout(); + mvaddstr(BASELINE, 8, " "); + + for(Line=TOPLINE; Line] [a]\n"); + fprintf(stderr, "The 'a' option causes the tower to be solved automatically\n"); +} + diff --git a/lib/libncurses/TESTS/knight.c b/lib/libncurses/TESTS/knight.c new file mode 100644 index 000000000000..4b2f98924e33 --- /dev/null +++ b/lib/libncurses/TESTS/knight.c @@ -0,0 +1,322 @@ +/* Knights Tour - a brain game */ + +#include +#include +#include +#include + +#ifdef __386BSD__ +#define srand48 srandom +#define lrand48 random +#endif + +short board [64]; /* the squares */ +char row, column; /* input characters */ +int rw,col; /* numeric equivalent of row and column */ +int curow,curcol; /* current row and column integers */ +int rdif, cdif; /* difference between input and current */ +int j; /* index into board */ + +char script[]={"'_)//,/(-)/__/__(_<_(__),|/|/_///_/_or< two squares in any direction and one square in a", +"perpendicular direction. He may not, of course, move off the board.", +"", +" At the beginning of a game you will be asked to either choose a", +"starting square or allow the computer to select a random location.", +"Squares are designated by a letter-number combination where the row is", +"specified by a letter A-H and the numbers 1-8 define a column. Invalid", +"entries are ignored and illegal moves produce a beep at the terminal.", +"", +" The objective is to visit every square on the board. When you claim", +"a square a marker is placed on it to show where you've been. You may", +"not revisit a square that you've landed on before.", +"", +" After each move the program checks to see if you have any legal", +"moves left. If not, the game ends and your squares are counted. If", +"you've made all the squares you win the game. Otherwise, you are told", +"the number of squares you did make.", +"END" +}; + +void init(void); +int play(void); +void drawboard(void); +void dosquares(void); +void getfirst(void); +void getrc(void); +void putstars(void); +int evalmove(void); +int chkmoves(void); +int endgame(void); +int chksqr(int, int); +void instruct(void); +void title(int, int); + +int +main () +{ + init (); + for (;;) + if (!play ()) { + endwin (); + exit (0); + } +} + +void +init () +{ + + srand48 (getpid()); + initscr (); + cbreak (); /* immediate char return */ + noecho (); /* no immediate echo */ + traceon(); + title (1,23); + traceoff(); + mvaddstr (23, 25, "Would you like instructions? "); + refresh(); + if ((toupper(getch())) == 'Y') + instruct(); + clear (); +} + +int +play () +{ + drawboard (); /* clear screen and drawboard */ + for (j = 0; j < 64; j++) board[j]=0; + getfirst (); /* get the starting square */ + for (;;) { + getrc(); + if (evalmove()) { + putstars (); + if (!chkmoves()) + return (endgame ()); + } + else beep(); + } +} + +void +drawboard () +{ + erase (); + dosquares (); + refresh (); + mvaddstr (0, 7, "1 2 3 4 5 6 7 8"); + for (j = 0; j < 8; j++) mvaddch (2*j+2, 3, j + 'A'); + refresh (); + mvaddstr (20, 5, "ROW:"); + mvaddstr (20, 27, "COLUMN:"); + mvaddstr (14, 49, "CURRENT ROW"); + mvaddstr (16, 49, "CURRENT COL"); + mvaddstr (22, 5, "A - H or Q to quit"); + mvaddstr (22, 27, "1 - 8 or ESC to cancel row"); + refresh (); + title (1,40); +} + +void +dosquares () +{ + mvaddstr (1, 6, "-------------------------------"); + for (j = 1; j < 9; j++){ + mvaddstr (2*j, 5, "| | | | | | | | |"); + mvaddstr (2*j+1, 6, "-------------------------------"); + } +} + +void +getfirst () /* get first square */ +{ + mvaddstr (23, 25, "(S)elect or (R)andom "); refresh (); + do { + row = toupper(getch()); + } while ((row != 'S') && (row != 'R')); + if (row == 'R') { + rw = lrand48() % 8; + col = lrand48() % 8; + j = 8* rw + col; + row = rw + 'A'; + column = col + '1'; + } + else { + mvaddstr (23, 25, "Enter starting row and column"); + refresh (); + getrc(); /* get row and column */ + } + putstars (); + move (23, 0); + clrtobot(); +} + +void +getrc () /* get row and column */ +{ + noecho (); + do { + mvaddstr (20, 35, " "); + refresh (); + do { + mvaddch (20, 11, ' '); + move (20, 11); + refresh (); + row=toupper(getch()); + if (row == 'Q') { + endwin (); + exit (1); + } + } while ((row < 'A') || (row > 'H')); + addch (row); + move (20, 35); + refresh (); + do { + column=getch(); + if (column == '\033') break; + } while ((column < '1') || (column > '8')); + if (column != '\033') addch (column); + } while (column == '\033'); + refresh(); + rw = row - 'A'; + col= column - '1'; + j = 8 * rw + col; +} + +void +putstars () /* place the stars, update board & currents */ +{ + mvaddch (2*curow+2, 38, ' '); + mvaddch (2*rw+2, 38, '<'); + mvaddch (18, curcol*4+7, ' '); + mvaddch (18, col*4+7, '^'); + curow = rw; + curcol= col; + mvaddstr (2 * rw + 2, 4*col+6, "***"); + mvaddch (14, 61, row); + mvaddch (16, 61, column); + refresh (); + board[j] = 1; +} + +int +evalmove() /* convert row and column to integers */ + /* and evaluate move */ +{ + rdif = rw - curow; + cdif = col - curcol; + rdif = abs(rw - curow); + cdif = abs(col - curcol); + refresh (); + if ((rdif == 1) && (cdif == 2)) if (board [j] == 0) return (1); + if ((rdif == 2) && (cdif == 1)) if (board [j] == 0) return (1); + return (0); +} + +int +chkmoves () /* check to see if valid moves are available */ +{ + if (chksqr(2,1)) return (1); + if (chksqr(2,-1)) return (1); + if (chksqr(-2,1)) return (1); + if (chksqr(-2,-1)) return (1); + if (chksqr(1,2)) return (1); + if (chksqr(1,-2)) return (1); + if (chksqr(-1,2)) return (1); + if (chksqr(-1,-2)) return (1); + return (0); +} + +int +endgame () /* check for filled board or not */ +{ + rw = 0; + for (j = 0; j < 64; j++) if (board[j] != 0) rw+=1; + if (rw == 64) mvaddstr (20, 20, "Congratulations !! You got 'em all"); + else mvprintw (20, 20, "You have ended up with %2d squares",rw); + mvaddstr (21, 25, "Play again ? (y/n) "); + refresh (); + if ((row=tolower(getch())) == 'y') return (1); + else return (0); +} + +#ifndef abs +abs(num) +int num; +{ + if (num < 0) return (-num); + else return (num); +} +#endif + +int +chksqr (int n1, int n2) +{ +int r1, c1; + + r1 = rw + n1; + c1 = col + n2; + if ((r1<0) || (r1>7)) return (0); + if ((c1<0) || (c1>7)) return (0); + if (board[r1*8+c1] == 0) return (1); + else return (0); +} + +void +instruct() +{ +int i; + + clear (); + for (i=0;;i++) { + if ((strcmp(instructions[i],"END"))) mvaddstr (i, 0, instructions[i]); + else { + mvaddstr (23, 25, "Ready to play ? (y/n) "); + refresh(); + if (toupper(getch()) == 'Y') { + clear (); + return; + } else { + clear (); + refresh (); + endwin (); + exit (0); + } + } + } +} + +void +title (y,x) +int y,x; +{ +char c; + + j = 0; + do { + c = script[j]; + if (c == 0) break ; + mvaddch (ypos[j]+y, xpos[j]+x, c); + j++; + } while (c != 0); + refresh (); +} + + diff --git a/lib/libncurses/TESTS/ncurses.c b/lib/libncurses/TESTS/ncurses.c new file mode 100644 index 000000000000..468cd5ddb75f --- /dev/null +++ b/lib/libncurses/TESTS/ncurses.c @@ -0,0 +1,1038 @@ +/**************************************************************************** + +NAME + ncurses.c --- ncurses library exerciser + +SYNOPSIS + ncurses + +DESCRIPTION + An interactive test module for the ncurses library. + +AUTHOR + This software is Copyright (C) 1993 by Eric S. Raymond, all rights reserved. +It is issued with ncurses under the same terms and conditions as the ncurses +library source. + +***************************************************************************/ +/*LINTLIBRARY */ +#include +#include +#include +#include +#include +#include + +#define P(s) printw("%s\n", s) +#ifndef CTRL +#define CTRL(x) ((x) & 0x1f) +#endif + +/**************************************************************************** + * + * Character input test + * + ****************************************************************************/ + +static void getch_test(void) +/* test the keypad feature */ +{ + unsigned int c; + int firsttime = 0; + + refresh(); + + c = '?'; + do { + if (firsttime++) + { + printw("Key pressed: %04o ", c); + if (c >= KEY_MIN) + { + (void) addstr(keyname(c)); + addch('\n'); + } + else if (c > 0x80) + { + if (isprint(c & ~0x80)) + (void) printw("M-%c", c); + else + (void) printw("M-%s", unctrl(c)); + addstr(" (high-half character)\n"); + } + else + { + if (isprint(c)) + (void) printw("%c (ASCII printable character)\n", c); + else + (void) printw("%s (ASCII control character)\n", unctrl(c)); + } + } + if (c == 'x' || c == 'q') + break; + if (c == '?') + addstr("Type any key to see its keypad value, `q' to quit, `?' for help.\n"); + } while + ((c = getch()) != EOF); + + erase(); + endwin(); +} + +static void attr_test(void) +/* test text attrivutes */ +{ + refresh(); + + mvaddstr(0, 20, "Character attribute test display"); + + mvaddstr(2,8,"This is STANDOUT mode: "); + attron(A_STANDOUT); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_STANDOUT); + + mvaddstr(4,8,"This is REVERSE mode: "); + attron(A_REVERSE); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_REVERSE); + + mvaddstr(6,8,"This is BOLD mode: "); + attron(A_BOLD); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_BOLD); + + mvaddstr(8,8,"This is UNDERLINE mode: "); + attron(A_UNDERLINE); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_UNDERLINE); + + mvaddstr(10,8,"This is DIM mode: "); + attron(A_DIM); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_DIM); + + mvaddstr(12,8,"This is BLINK mode: "); + attron(A_BLINK); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_BLINK); + + mvaddstr(14,8,"This is BOLD UNDERLINE BLINK mode: "); + attron(A_BOLD|A_BLINK|A_UNDERLINE); + addstr("abcde fghij klmno pqrst uvwxy x"); + attroff(A_BOLD|A_BLINK|A_UNDERLINE); + + attrset(A_NORMAL); + mvaddstr(16,8,"This is NORMAL mode: "); + addstr("abcde fghij klmno pqrst uvwxy x"); + + refresh(); + + move(LINES - 1, 0); + addstr("Press any key to continue... "); + (void) getch(); + + erase(); + endwin(); +} + +/**************************************************************************** + * + * Color support tests + * + ****************************************************************************/ + +static char *colors[] = +{ + "black", + "red", + "green", + "yellow", + "blue", + "magenta", + "cyan", + "white" +}; + +static void color_test(void) +/* generate a color test pattern */ +{ + int i; + + refresh(); + (void) printw("There are %d color pairs\n", COLOR_PAIRS); + + (void) mvprintw(1, 0, + "%dx%d matrix of foreground/background colors, bright *off*\n", + COLORS, COLORS); + for (i = 0; i < COLORS; i++) + mvaddstr(2, (i+1) * 8, colors[i]); + for (i = 0; i < COLORS; i++) + mvaddstr(3 + i, 0, colors[i]); + for (i = 1; i < COLOR_PAIRS; i++) + { + init_pair(i, i % COLORS, i / COLORS); + attron(COLOR_PAIR(i)); + mvaddstr(3 + (i / COLORS), (i % COLORS + 1) * 8, "Hello"); + attrset(A_NORMAL); + } + + (void) mvprintw(COLORS + 4, 0, + "%dx%d matrix of foreground/background colors, bright *on*\n", + COLORS, COLORS); + for (i = 0; i < COLORS; i++) + mvaddstr(5 + COLORS, (i+1) * 8, colors[i]); + for (i = 0; i < COLORS; i++) + mvaddstr(6 + COLORS + i, 0, colors[i]); + for (i = 1; i < COLOR_PAIRS; i++) + { + init_pair(i, i % COLORS, i / COLORS); + attron(COLOR_PAIR(i) | A_BOLD); + mvaddstr(6 + COLORS + (i / COLORS), (i % COLORS + 1) * 8, "Hello"); + attrset(A_NORMAL); + } + + move(LINES - 1, 0); + addstr("Press any key to continue... "); + (void) getch(); + + erase(); + endwin(); +} + +static void color_edit(void) +/* display the color test pattern, without trying to edit colors */ +{ + int i, c, value = 0, current = 0, field = 0, usebase = 0; + + refresh(); + + for (i = 0; i < COLORS; i++) + init_pair(i, COLOR_WHITE, i); + + do { + short red, green, blue; + + attron(A_BOLD); + mvaddstr(0, 20, "Color RGB Value Editing"); + attroff(A_BOLD); + + for (i = 0; i < COLORS; i++) + { + mvprintw(2 + i, 0, "%c %-8s:", + (i == current ? '>' : ' '), + (i < sizeof(colors)/sizeof(colors[0]) ? colors[i] : "")); + attrset(COLOR_PAIR(i)); + addstr(" "); + attrset(A_NORMAL); + + /* + * Note: this refresh should *not* be necessary! It works around + * a bug in attribute handling that apparently causes the A_NORMAL + * attribute sets to interfere with the actual emission of the + * color setting somehow. This needs to be fixed. + */ + refresh(); + + color_content(i, &red, &green, &blue); + addstr(" R = "); + if (current == i && field == 0) attron(A_STANDOUT); + printw("%04d", red); + if (current == i && field == 0) attrset(A_NORMAL); + addstr(", G = "); + if (current == i && field == 1) attron(A_STANDOUT); + printw("%04d", green); + if (current == i && field == 1) attrset(A_NORMAL); + addstr(", B = "); + if (current == i && field == 2) attron(A_STANDOUT); + printw("%04d", blue); + if (current == i && field == 2) attrset(A_NORMAL); + attrset(A_NORMAL); + addstr(")"); + } + + mvaddstr(COLORS + 3, 0, + "Use up/down to select a color, left/right to change fields."); + mvaddstr(COLORS + 4, 0, + "Modify field by typing nnn=, nnn-, or nnn+. ? for help."); + + move(2 + current, 0); + + switch (c = getch()) + { + case KEY_UP: + current = (current == 0 ? (COLORS - 1) : current - 1); + value = 0; + break; + + case KEY_DOWN: + current = (current == (COLORS - 1) ? 0 : current + 1); + value = 0; + break; + + case KEY_RIGHT: + field = (field == 2 ? 0 : field + 1); + value = 0; + break; + + case KEY_LEFT: + field = (field == 0 ? 2 : field - 1); + value = 0; + break; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + do { + value = value * 10 + (c - '0'); + c = getch(); + } while + (isdigit(c)); + if (c != '+' && c != '-' && c != '=') + beep(); + else + ungetch(c); + break; + + case '+': + usebase = 1; + goto changeit; + + case '-': + value = -value; + usebase = 1; + goto changeit; + + case '=': + usebase = 0; + changeit: + color_content(current, &red, &green, &blue); + if (field == 0) + red = red * usebase + value; + else if (field == 1) + green = green * usebase + value; + else if (field == 2) + blue = blue * usebase + value; + init_color(current, red, green, blue); + break; + + case '?': + erase(); + P(" RGB Value Editing Help"); + P(""); + P("You are in the RGB value editor. Use the arrow keys to select one of"); + P("the fields in one of the RGB triples of the current colors; the one"); + P("currently selected will be reverse-video highlighted."); + P(""); + P("To change a field, enter the digits of the new value; they won't be"); + P("echoed. Finish by typing `='; the change will take effect instantly."); + P("To increment or decrement a value, use the same procedure, but finish"); + P("with a `+' or `-'."); + P(""); + P("To quit, do `x' or 'q'"); + + move(LINES - 1, 0); + addstr("Press any key to continue... "); + (void) getch(); + erase(); + break; + + case 'x': + case 'q': + break; + + default: + beep(); + break; + } + } while + (c != 'x' && c != 'q'); + + erase(); + endwin(); +} + +/**************************************************************************** + * + * Soft-key label test + * + ****************************************************************************/ + +static void slk_test(void) +/* exercise the soft keys */ +{ + int c, fmt = 1; + char buf[9]; + + c = CTRL('l'); + do { + switch(c) + { + case CTRL('l'): + erase(); + attron(A_BOLD); + mvaddstr(0, 20, "Soft Key Exerciser"); + attroff(A_BOLD); + + move(2, 0); + P("Available commands are:"); + P(""); + P("^L -- refresh screen"); + P("a -- activate or restore soft keys"); + P("d -- disable soft keys"); + P("c -- set centered format for labels"); + P("l -- set left-justified format for labels"); + P("r -- set right-justified format for labels"); + P("[12345678] -- set label; labels are numbered 1 through 8"); + P("e -- erase stdscr (should not erase labels)"); + P("s -- test scrolling of shortened screen"); + P("x, q -- return to main menu"); + P(""); + P("Note: if activating the soft keys causes your terminal to"); + P("scroll up one line, your terminal auto-scrolls when anything"); + P("is written to the last screen position. The ncurses code"); + P("does not yet handle this gracefully."); + refresh(); + /* fall through */ + + case 'a': + slk_restore(); + break; + + case 'e': + wclear(stdscr); + break; + + case 's': + move(20, 0); + while ((c = getch()) != 'Q') + addch(c); + break; + + case 'd': + slk_clear(); + break; + + case 'l': + fmt = 0; + break; + + case 'c': + fmt = 1; + break; + + case 'r': + fmt = 2; + break; + + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': + (void) mvaddstr(20, 0, "Please enter the label value: "); + wgetnstr(stdscr, buf, 8); + slk_set((c - '0'), buf, fmt); + slk_refresh(); + break; + + case 'x': + case 'q': + goto done; + + default: + beep(); + } + } while + ((c = getch()) != EOF); + + done: + erase(); + endwin(); +} + +/**************************************************************************** + * + * Alternate character-set stuff + * + ****************************************************************************/ + +static void acs_display() +/* display the ACS character set */ +{ +traceon(); + erase(); + attron(A_BOLD); + mvaddstr(0, 20, "Display of the ACS Character Set"); + attroff(A_BOLD); + refresh(); + +#define ACSY 5 + mvaddstr(ACSY + 0, 0, "ACS_ULCORNER: "); addch(ACS_ULCORNER); + mvaddstr(ACSY + 1, 0, "ACS_LLCORNER: "); addch(ACS_LLCORNER); + mvaddstr(ACSY + 2, 0, "ACS_URCORNER: "); addch(ACS_URCORNER); + mvaddstr(ACSY + 3, 0, "ACS_LRCORNER: "); addch(ACS_LRCORNER); + mvaddstr(ACSY + 4, 0, "ACS_RTEE: "); addch(ACS_RTEE); + mvaddstr(ACSY + 5, 0, "ACS_LTEE: "); addch(ACS_LTEE); + mvaddstr(ACSY + 6, 0, "ACS_BTEE: "); addch(ACS_BTEE); + mvaddstr(ACSY + 7, 0, "ACS_TTEE: "); addch(ACS_TTEE); + mvaddstr(ACSY + 8, 0, "ACS_HLINE: "); addch(ACS_HLINE); + mvaddstr(ACSY + 9, 0, "ACS_VLINE: "); addch(ACS_VLINE); + mvaddstr(ACSY + 10,0, "ACS_PLUS: "); addch(ACS_PLUS); + mvaddstr(ACSY + 11,0, "ACS_S1: "); addch(ACS_S1); + mvaddstr(ACSY + 12,0, "ACS_S9: "); addch(ACS_S9); + + mvaddstr(ACSY + 0, 40, "ACS_DIAMOND: "); addch(ACS_DIAMOND); + mvaddstr(ACSY + 1, 40, "ACS_CKBOARD: "); addch(ACS_CKBOARD); + mvaddstr(ACSY + 2, 40, "ACS_DEGREE: "); addch(ACS_DEGREE); + mvaddstr(ACSY + 3, 40, "ACS_PLMINUS: "); addch(ACS_PLMINUS); + mvaddstr(ACSY + 4, 40, "ACS_BULLET: "); addch(ACS_BULLET); + mvaddstr(ACSY + 5, 40, "ACS_LARROW: "); addch(ACS_LARROW); + mvaddstr(ACSY + 6, 40, "ACS_RARROW: "); addch(ACS_RARROW); + mvaddstr(ACSY + 7, 40, "ACS_DARROW: "); addch(ACS_DARROW); + mvaddstr(ACSY + 8, 40, "ACS_UARROW: "); addch(ACS_UARROW); + mvaddstr(ACSY + 9, 40, "ACS_BOARD: "); addch(ACS_BOARD); + mvaddstr(ACSY + 10,40, "ACS_LANTERN: "); addch(ACS_LANTERN); + mvaddstr(ACSY + 11,40, "ACS_BLOCK: "); addch(ACS_BLOCK); + + move(LINES - 1, 0); + addstr("Press any key to continue... "); + (void) getch(); + + erase(); + endwin(); +} + +/**************************************************************************** + * + * Windows and scrolling tester. + * + ****************************************************************************/ + +typedef struct +{ + int y, x; +} +pair; + +static void report(void) +/* report on the cursor's current position, then restore it */ +{ + int y, x; + + getyx(stdscr, y, x); + move(LINES - 1, COLS - 17); + printw("Y = %2d X = %2d", y, x); + move(y, x); +} + +static pair *selectcell(uli, ulj, lri, lrj) +/* arrows keys move cursor, return location at current on non-arrow key */ +int uli, ulj, lri, lrj; /* co-ordinates of corners */ +{ + static pair res; /* result cell */ + int si = lri - uli + 1; /* depth of the select area */ + int sj = lrj - ulj + 1; /* width of the select area */ + int i = 0, j = 0; /* offsets into the select area */ + + for (;;) + { + move(LINES - 1, COLS - 17); + printw("Y = %2d X = %2d", uli + i, ulj + j); + move(uli + i, ulj + j); + + switch(getch()) + { + case KEY_UP: i += si - 1; break; + case KEY_DOWN: i++; break; + case KEY_LEFT: j += sj - 1; break; + case KEY_RIGHT: j++; break; + default: res.y = uli + i; res.x = ulj + j; return(&res); + } + i %= si; + j %= sj; + } +} + +static WINDOW *getwindow(void) +/* Ask user for a window definition */ +{ + WINDOW *rwindow, *bwindow; + pair ul, lr; + + move(0, 0); clrtoeol(); + addstr("Use arrows to move cursor, anything else to mark corner 1"); + refresh(); + memcpy(&ul, selectcell(1, 0, LINES-1, COLS-1), sizeof(pair)); + addch(ACS_ULCORNER); + move(0, 0); clrtoeol(); + addstr("Use arrows to move cursor, anything else to mark corner 2"); + refresh(); + memcpy(&lr, selectcell(ul.y, ul.x, LINES-1, COLS-1), sizeof(pair)); + + rwindow = newwin(lr.y - ul.y + 1, lr.x - ul.x + 1, ul.y, ul.x); + + bwindow = newwin(lr.y - ul.y + 3, lr.x - ul.x + 3, ul.y - 1, ul.x - 1); + wborder(bwindow, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, + 0, 0, 0, 0); + wrefresh(bwindow); + delwin(bwindow); + + scrollok(rwindow, TRUE); +/* immedok(rwindow); */ + wrefresh(rwindow); + + return(rwindow); +} + +static void acs_and_scroll() +/* Demonstrate windows */ +{ + int c; + struct frame + { + struct frame *next, *last; + WINDOW *wind; + } + *oldw = (struct frame *)NULL, *current = (struct frame *)NULL, *neww; + + refresh(); + mvaddstr(LINES - 2, 0, + "F1 = make new window, F2 = next window, F3 = previous window"); + mvaddstr(LINES - 1, 0, + "All other characters are echoed, windows should scroll."); + + c = KEY_F(1); + do { + report(); + if (current) + wrefresh(current->wind); + + switch(c) + { + case KEY_F(1): + neww = (struct frame *) malloc(sizeof(struct frame)); + neww->wind = getwindow(); + if (oldw == NULL) /* First element, */ + { + neww->next = neww; /* so point it at itself */ + neww->last = neww; + current = neww; + } + else + { + neww->last = oldw; oldw->next = neww; + neww->next = current; current->last = neww; + } + oldw = neww; + keypad(neww->wind, TRUE); + break; + + case KEY_F(2): + current = current->next; + break; + + case KEY_F(3): + current = current->last; + break; + + case KEY_F(4): /* undocumented --- use this to test area clears */ + selectcell(0, 0, LINES - 1, COLS - 1); + clrtobot(); + refresh(); + break; + + case '\r': + c = '\n'; + /* FALLTHROUGH */ + + default: + waddch(current->wind, c); + break; + } + report(); + wrefresh(current->wind); + } while + ((c = wgetch(current->wind)) != '\004'); + + erase(); + endwin(); +} + +/**************************************************************************** + * + * Tests from John Burnell's PDCurses tester + * + ****************************************************************************/ + +static void demo_pad(void) +/* Demonstrate pads. */ +{ + WINDOW *pad; + + pad = newpad(50,100); + mvwaddstr(pad, 5, 2, "This is a new pad"); + mvwaddstr(pad, 8, 0, "The end of this line should be truncated here:abcd"); + mvwaddstr(pad,11, 1, "This line should not appear."); + wmove(pad, 10, 1); + wclrtoeol(pad); + mvwaddstr(pad, 10, 1, " Press any key to continue"); + prefresh(pad,0,0,0,0,10,45); + keypad(pad, TRUE); + wgetch(pad); + + mvwaddstr(pad, 35, 2, "This is displayed at line 35 in the pad"); + mvwaddstr(pad, 40, 1, " Press any key to continue"); + prefresh(pad,30,0,0,0,10,45); + keypad(pad, TRUE); + wgetch(pad); + + delwin(pad); +} + +static void Continue (WINDOW *win) +{ + wmove(win, 10, 1); + mvwaddstr(win, 10, 1, " Press any key to continue"); + wrefresh(win); + wgetch(win); +} + +static void input_test(WINDOW *win) +/* Input test, adapted from John Burnell's PDCurses tester */ +{ + int w, h, bx, by, sw, sh, i, c,num; + char buffer [80]; + WINDOW *subWin; + wclear (win); + + w = win->_maxx; + h = win->_maxy; + bx = win->_begx; + by = win->_begy; + sw = w / 3; + sh = h / 3; + if((subWin = subwin(win, sh, sw, by + h - sh - 2, bx + w - sw - 2)) == NULL) + return; + +#ifdef A_COLOR + if (has_colors()) + { + init_pair(2,COLOR_CYAN,COLOR_BLUE); + wattrset(subWin, COLOR_PAIR(2) | A_BOLD); + } + else + wattrset(subWin, A_BOLD); +#else + wattrset(subWin, A_BOLD); +#endif + box(subWin, ACS_VLINE, ACS_HLINE); + wrefresh(win); + + nocbreak(); + mvwaddstr(win, 2, 1, "Press some keys for 5 seconds"); + mvwaddstr(win, 1, 1, "Pressing ^C should do nothing"); + wrefresh(win); + + for (i = 0; i < 5; i++) { + werase (subWin); + box(subWin, ACS_VLINE, ACS_HLINE); + mvwprintw (subWin, 1, 1, "Time = %d", i); + wrefresh(subWin); + sleep(1); + flushinp(); + } + + delwin (subWin); + werase(win); + flash(); + wrefresh(win); + sleep(1); + + mvwaddstr(win, 2, 1, "Press a key"); + wmove(win, 9, 10); + wrefresh(win); + echo(); + wgetch(win); + flushinp(); + + wmove(win, 9, 10); + wdelch(win); + mvwaddstr(win, 4, 1, "The character should now have been deleted"); + Continue(win); + + wclear (win); + mvwaddstr(win, 2, 1, "Press a function key or an arrow key"); + wrefresh(win); + keypad(win, TRUE); + c = wgetch(win); + + nodelay(win, TRUE); + wgetch(win); + nodelay(win, FALSE); + + refresh(); + wclear (win); + mvwaddstr(win, 3, 2, "The window should have moved"); + mvwaddstr(win, 4, 2, "This text should have appeared without you pressing a key"); + mvwprintw(win, 2, 2, "Keycode = %d", c); + +#ifdef FOO + /* + * This test won't be portable until vsscanf() is + */ + mvwaddstr(win, 6, 2, "Enter a number then a string separated by space"); + echo(); + mvwscanw(win, 7, 6, "%d %s", &num,buffer); + mvwprintw(win, 8, 6, "String: %s Number: %d", buffer,num); +#endif /* FOO */ + + Continue(win); +} + +static void output_test (WINDOW *win) +{ + WINDOW *win1; + char Buffer [80]; + chtype ch; + + wclear (win); + mvwaddstr(win, 1, 1, "You should now have a screen in the upper left corner, and this text should have wrapped"); + mvwin(win, 2, 1); + Continue(win); + + nl(); + wclear(win); + mvwaddstr(win, 1, 1, "A new window will appear with this text in it"); + mvwaddstr(win, 8, 1, "Press any key to continue"); + wrefresh(win); + wgetch(win); + + win1 = newwin(10, 50, 15, 25); + if(win1 == NULL) + { endwin(); + return; + } +#ifdef A_COLOR + if (has_colors()) + { + init_pair(3,COLOR_BLUE,COLOR_WHITE); + wattrset(win1, COLOR_PAIR(3)); + } + else + wattrset(win1, A_NORMAL); +#else + wattrset(win1, A_NORMAL); +#endif + wclear (win1); + mvwaddstr(win1, 5, 1, "This text should appear; using overlay option"); + copywin(win, win1,0,0,0,0,10,50,TRUE); + + box(win1,ACS_VLINE,ACS_HLINE); + wmove(win1, 8, 26); + wrefresh(win1); + wgetch(win1); + + wclear(win1); + wattron(win1, A_BLINK); + mvwaddstr(win1, 4, 1, "This blinking text should appear in only the second window"); + wattroff(win1, A_BLINK); + wrefresh(win1); + wgetch(win1); + delwin(win1); + + wclear(win); + wrefresh(win); + mvwaddstr(win, 6, 2, "This line shouldn't appear"); + mvwaddstr(win, 4, 2, "Only half of the next line is visible"); + mvwaddstr(win, 5, 2, "Only half of the next line is visible"); + wmove(win, 6, 1); + wclrtobot (win); + wmove(win, 5, 20); + wclrtoeol (win); + mvwaddstr(win, 8, 2, "This line also shouldn't appear"); + wmove(win, 8, 1); + wdeleteln(win); + Continue(win); + traceoff(); + + wmove (win, 5, 9); + ch = winch (win); + + wclear(win); + wmove (win, 6, 2); + waddstr (win, "The next char should be l: "); + winsch (win, ch); + Continue(win); + + wmove(win, 5, 1); + winsertln (win); + mvwaddstr(win, 5, 2, "The lines below should have moved down"); + Continue(win); + +#ifdef FOO + /* + * This test won't be portable until vsscanf() is + */ + wclear(win); + wmove(win, 2, 2); + wprintw(win, "This is a formatted string in a window: %d %s\n", 42, "is it"); + mvwaddstr(win, 10, 1, "Enter a string: "); + wrefresh(win); + echo(); + wscanw (win, "%s", Buffer); + + wclear(win); + mvwaddstr(win, 10, 1, "Enter a string"); + wrefresh(win); + clear(); + move(0,0); + printw("This is a formatted string in stdscr: %d %s\n", 42, "is it"); + mvaddstr(10, 1, "Enter a string: "); + refresh(); + echo(); + scanw ("%s", Buffer); +#endif /* FOO */ + + wclear(win); + curs_set(2); + mvwaddstr(win, 1, 1, "The cursor should appear as a block"); + Continue(win); + + wclear(win); + curs_set(0); + mvwaddstr(win, 1, 1, "The cursor should have disappeared"); + Continue(win); + + wclear(win); + curs_set(1); + mvwaddstr(win, 1, 1, "The cursor should be an underline"); + Continue(win); +} + +/**************************************************************************** + * + * Main sequence + * + ****************************************************************************/ + +bool do_single_test(const char c) +/* perform a single specified test */ +{ + switch (c) + { + case 'a': + getch_test(); + return(TRUE); + + case 'b': + attr_test(); + return(TRUE); + + case 'c': + if (!has_colors()) + (void) printf("This %s terminal does not support color.\n", + getenv("TERM")); + else + color_test(); + return(TRUE); + + case 'd': + if (!has_colors()) + (void) printf("This %s terminal does not support color.\n", + getenv("TERM")); + else if (!can_change_color()) + (void) printf("This %s terminal has hardwired color values.\n", + getenv("TERM")); + else + color_edit(); + return(TRUE); + + case 'e': + slk_test(); + return(TRUE); + + case 'f': + acs_display(); + return(TRUE); + + case 'g': + acs_and_scroll(); + return(TRUE); + + case 'p': + demo_pad(); + return(TRUE); + + case 'i': + input_test(stdscr); + return(TRUE); + + case 'o': + output_test(stdscr); + return(TRUE); + + case '?': + (void) puts("This is the ncurses capability tester."); + (void) puts("You may select a test from the main menu by typing the"); + (void) puts("key letter of the choice (the letter to left of the =)"); + (void) puts("at the > prompt. The commands `x' or `q' will exit."); + return(TRUE); + } + + return(FALSE); +} + +int main(const int argc, const char *argv[]) +{ + char buf[BUFSIZ]; + + /* enable debugging */ + traceon(); + + /* tell it we're going to play with soft keys */ + slk_init(1); + + /* we must initialize the curses data structure only once */ + initscr(); + + /* tests, in general, will want these modes */ + start_color(); + cbreak(); + noecho(); + scrollok(stdscr, TRUE); + keypad(stdscr, TRUE); + + /* + * Return to terminal mode, so we're guaranteed of being able to + * select terminal commands even if the capabilities are wrong. + */ + endwin(); + + (void) puts("Welcome to ncurses. Press ? for help."); + + do { + (void) puts("This is the ncurses main menu"); + (void) puts("a = character input test"); + (void) puts("b = character attribute test"); + (void) puts("c = color test pattern"); + (void) puts("d = edit RGB color values"); + (void) puts("e = exercise soft keys"); + (void) puts("f = display ACS characters"); + (void) puts("g = display windows and scrolling"); + (void) puts("p = exercise pad features"); + (void) puts("i = subwindow input test"); + (void) puts("o = output test"); + (void) puts("? = get help"); + + (void) fputs("> ", stdout); + (void) fgets(buf, BUFSIZ, stdin); + + if (do_single_test(buf[0])) { + clear(); + refresh(); + endwin(); + continue; + } + } while + (buf[0] != 'q' && buf[0] != 'x'); + + exit(0); +} + +/* ncurses.c ends here */ diff --git a/lib/libncurses/TESTS/newdemo.c b/lib/libncurses/TESTS/newdemo.c new file mode 100644 index 000000000000..97c368d1bd5d --- /dev/null +++ b/lib/libncurses/TESTS/newdemo.c @@ -0,0 +1,350 @@ +/* $Header: c:/curses/demos/RCS/newdemo.c%v 2.0 1992/11/15 03:32:03 MH Rel $ + * + * newdemo.c - A demo program using PDCurses. The program illustrate + * the use of colours for text output. + */ + +#include +#include +#include +#include + +#define delay_output(x) + +/* + * The Australian map + */ +char *AusMap[16] = +{ + " A A ", + " N.T. AAAAA AAAA ", + " AAAAAAAAAAA AAAAAAAA ", + " AAAAAAAAAAAAAAAAAAAAAAAAA Qld.", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ", + " AAAAAAAAAAAAAAAAAAAAAAAAAAAA ", + " AAAAAAAAAAAAAAAAAAAAAAAAA N.S.W.", + "W.A. AAAAAAAAA AAAAAA Vic.", + " AAA S.A. AA", + " A Tas.", + "" +}; + +/* + * Funny messages + */ +#define NMESSAGES 6 + +char *messages[] = +{ + "Hello from the Land Down Under", + "The Land of crocs. and a big Red Rock", + "Where the sunflower runs along the highways", + "the dusty red roads lead one to loneliness", + "Blue sky in the morning and", + "freezing nights and twinkling stars", + "" +}; + +/* + * Main driver + */ +main() +{ +WINDOW *win; +int w, x, y, i, j, c, len; +time_t t; +char buffer[80], *message; +int width, height; +chtype save[80]; +void trap(); + + initscr(); + start_color(); + cbreak(); + signal(SIGINT, trap); + width = 48; + height = 14; /* Create a drawing window */ + win = newwin(height, width, (LINES-height)/2, (COLS-width)/2); + if(win == NULL) + { endwin(); + return 1; + } + + while(1) + { init_pair(1,COLOR_WHITE,COLOR_BLUE); + wattrset(win, COLOR_PAIR(1)); + werase(win); + + init_pair(2,COLOR_RED,COLOR_RED); + wattrset(win, COLOR_PAIR(2)); + box(win, ACS_VLINE, ACS_HLINE); + wrefresh(win); + /* Do ramdom output of a character */ + wattrset(win, COLOR_PAIR(1)); + c = 'a'; + for(i=0; i < 5000; ++i) + { x = rand() % (width-2) + 1; + y = rand() % (height-2) + 1; + mvwaddch(win, y, x, c); + wrefresh(win); + nodelay(win,TRUE); + if (wgetch(win) != ERR) + break; + if(i == 2000) + { c = 'b'; + init_pair(3,COLOR_CYAN,COLOR_YELLOW); + wattron(win, COLOR_PAIR(3)); + } + } + + SubWinTest(win); + /* Erase and draw green window */ + init_pair(4,COLOR_YELLOW,COLOR_GREEN); + wattrset(win, COLOR_PAIR(4) | A_BOLD); + werase(win); + wrefresh(win); + /* Draw RED bounding box */ + wattrset(win, COLOR_PAIR(2)); + box(win, ' ', ' '); + wrefresh(win); + /* Display Australia map */ + wattrset(win, COLOR_PAIR(4) | A_BOLD); + i = 0; + while(*AusMap[i]) + { mvwaddstr(win, i+1, 8, AusMap[i]); + wrefresh(win); + delay_output(100); + ++i; + } + + init_pair(5,COLOR_BLUE,COLOR_WHITE); + wattrset(win, COLOR_PAIR(5) | A_BLINK); + mvwaddstr(win, height-2, 6, " PDCurses 2.1 for DOS, OS/2 and Unix"); + wrefresh(win); + + /* Draw running messages */ + init_pair(6,COLOR_YELLOW,COLOR_WHITE); + wattrset(win, COLOR_PAIR(6)); + message = messages[0]; + len = strlen(message); + j = 0; + i = 2; + w = width-2; + while(j < NMESSAGES) + { strncpy(buffer, message, w - i); + buffer[w-i] = 0; + mvwaddstr(win, height/2, i, buffer); + if(w - i < len) + { memset(buffer, ' ', i); + strcpy(buffer, message + (w - i)); + buffer[strlen(buffer)] = ' '; + buffer[i-2] = '\0'; + mvwaddstr(win, height/2, 2, buffer); + } + wrefresh(win); + nodelay(win,TRUE); + if (wgetch(win) != ERR) + { flushinp(); + break; + } + mvwaddch(win, height/2, i, ' '); + i = ++i % w; + if(i < 2) + { message = messages[++j%NMESSAGES]; + memset(buffer, ' ', w-2); + buffer[w-2] = 0; + mvwaddstr(win, height/2, 2, buffer); + i = 2; + } + delay_output(300); + } + + j = 0; + /* Draw running As across in RED */ + init_pair(7,COLOR_RED,COLOR_GREEN); + wattron(win, COLOR_PAIR(7)); + for(i=2; i < width - 4; ++i) + { c = mvwinch(win, 4, i); + save[j++] = c; + c = c & 0x7f; + mvwaddch(win, 4, i, c); + } + wrefresh(win); + + /* Put a message up wait for a key */ + i = height-2; + wattrset(win, COLOR_PAIR(5)); + mvwaddstr(win, i, 5, " Type a key to continue or 'Q' to quit "); + wrefresh(win); + + if(WaitForUser() == 1) + break; + + j = 0; /* Restore the old line */ + for(i=2; i < width - 4; ++i) + mvwaddch(win, 4, i, save[j++]); + wrefresh(win); + + BouncingBalls(win); + /* Put a message up wait for a key */ + i = height-2; + wattrset(win, COLOR_PAIR(5)); + mvwaddstr(win, i, 5, " Type a key to continue or 'Q' to quit "); + wrefresh(win); + if(WaitForUser() == 1) + break; + } +exit: + endwin(); + return 0; +} + +/* + * Test sub windows + */ +SubWinTest(WINDOW *win) +{ +int w, h, sw, sh, bx, by; +WINDOW *swin1, *swin2, *swin3; + + w = win->_maxx; + h = win->_maxy; + bx = win->_begx; + by = win->_begy; + sw = w / 3; + sh = h / 3; + if((swin1 = subwin(win, sh, sw, by+3, bx+5)) == NULL) + return 1; + if((swin2 = subwin(win, sh, sw, by+4, bx+8)) == NULL) + return 1; + if((swin3 = subwin(win, sh, sw, by+5, bx+11)) == NULL) + return 1; + + init_pair(8,COLOR_RED,COLOR_BLUE); + wattrset(swin1, COLOR_PAIR(8)); + werase(swin1); + mvwaddstr(swin1, 0, 3, "Sub-window 1"); + wrefresh(swin1); + + init_pair(8,COLOR_CYAN,COLOR_MAGENTA); + wattrset(swin2, COLOR_PAIR(8)); + werase(swin2); + mvwaddstr(swin2, 0, 3, "Sub-window 2"); + wrefresh(swin2); + + init_pair(8,COLOR_YELLOW,COLOR_GREEN); + wattrset(swin3, COLOR_PAIR(8)); + werase(swin3); + mvwaddstr(swin3, 0, 3, "Sub-window 3"); + wrefresh(swin3); + + delwin(swin1); + delwin(swin2); + delwin(swin3); + WaitForUser(); + return 0; +} + +/* + * Bouncing balls + */ +BouncingBalls(WINDOW *win) +{ +chtype c1, c2, c3; +int w, h; +int x1, y1, xd1, yd1; +int x2, y2, xd2, yd2; +int x3, y3, xd3, yd3; + + w = win->_maxx; + h = win->_maxy; + x1 = 2 + rand() % (w - 4); + y1 = 2 + rand() % (h - 4); + x2 = 2 + rand() % (w - 4); + y2 = 2 + rand() % (h - 4); + x3 = 2 + rand() % (w - 4); + y3 = 2 + rand() % (h - 4); + xd1 = 1; yd1 = 1; + xd2 = 1; yd2 = 0; + xd3 = 0; yd3 = 1; + nodelay(win,TRUE); + while(wgetch(win) == ERR) + { x1 = xd1 > 0 ? ++x1 : --x1; + if(x1 <= 1 || x1 >= w - 2) + xd1 = xd1 ? 0 : 1; + y1 = yd1 > 0 ? ++y1 : --y1; + if(y1 <= 1 || y1 >= h - 2) + yd1 = yd1 ? 0 : 1; + + x2 = xd2 > 0 ? ++x2 : --x2; + if(x2 <= 1 || x2 >= w - 2) + xd2 = xd2 ? 0 : 1; + y2 = yd2 > 0 ? ++y2 : --y2; + if(y2 <= 1 || y2 >= h - 2) + yd2 = yd2 ? 0 : 1; + + x3 = xd3 > 0 ? ++x3 : --x3; + if(x3 <= 1 || x3 >= w - 2) + xd3 = xd3 ? 0 : 1; + y3 = yd3 > 0 ? ++y3 : --y3; + if(y3 <= 1 || y3 >= h - 2) + yd3 = yd3 ? 0 : 1; + + c1 = mvwinch(win, y1, x1); + c2 = mvwinch(win, y2, x2); + c3 = mvwinch(win, y3, x3); + + init_pair(8,COLOR_RED,COLOR_BLUE); + wattrset(win, COLOR_PAIR(8)); + mvwaddch(win, y1, x1, 'O'); + init_pair(8,COLOR_BLUE,COLOR_RED); + wattrset(win, COLOR_PAIR(8)); + mvwaddch(win, y2, x2, '*'); + init_pair(8,COLOR_YELLOW,COLOR_WHITE); + wattrset(win, COLOR_PAIR(8)); + mvwaddch(win, y3, x3, '@'); + wmove(win, 0, 0); + wrefresh(win); + mvwaddch(win, y1, x1, c1); + mvwaddch(win, y2, x2, c2); + mvwaddch(win, y3, x3, c3); + delay_output(150); + } + return 0; +} + +/* + * Wait for user + */ +int WaitForUser() +{ + time_t t; + chtype key; + + nodelay(stdscr,TRUE); + t = time((time_t *)0); + while(1) + { + if ((key = getch()) != ERR) + { + if (key == 'q' || key == 'Q') + return 1; + else + return 0; + } + if (time((time_t *)0) - t > 5) + return 0; + } +} + +/* + * Trap interrupt + */ +void trap() +{ + endwin(); + exit(0); +} + +/* End of DEMO.C */ diff --git a/lib/libncurses/TESTS/over.c b/lib/libncurses/TESTS/over.c new file mode 100644 index 000000000000..530e48d35574 --- /dev/null +++ b/lib/libncurses/TESTS/over.c @@ -0,0 +1,120 @@ +/********************************************************************* + * [program] overwrite() - Play with overwrite() function to * + * attempt pop-up windows. * + * ----------------------------------------------------------------- * + * [written] 1-Feb-1993 by Neal Ensor (ensor@cs.utk.edu) * + * ----------------------------------------------------------------- * + * [notes] Originally written on SVR4 UNIX, then recompiled on * + * Linux (Slackware 1.1.1, ncurses 1.8.1) * + * ----------------------------------------------------------------- * + * [problem] On ncurses, the overwrite() function doesn't seem to * + * overwrite. Maybe I'm missing something, but this * + * program in SVR4 displays three windows, waits for a * + * keypress, then removes the top window. With ncurses, * + * nothing changes on the display. * + *********************************************************************/ + +# include /* ncurses include lives here */ + +main() +{ + /**************************************************************** + * Declare three little window pointers... * + ****************************************************************/ + WINDOW *win, *win1, *win2; + + /**************************************************************** + * Set up the screen... * + ****************************************************************/ + initscr(); + traceon(); + noecho(); + nonl(); + cbreak(); + refresh(); + + /**************************************************************** + * Draw three overlapping windows. * + ****************************************************************/ + win=newwin(6,45, 6,6); + win1=newwin(10,20,5,5); + win2=newwin(10,30,7,7); + + /**************************************************************** + * Box them, and print a hidden message... * + ****************************************************************/ + box(win, 0, 0); + box(win1, 0, 0); + box(win2, 0, 0); + mvwprintw(win1, 6,6, "Hey!"); + mvwaddch(win, 1, 1, '0'); + mvwaddch(win1, 1, 1, '1'); + mvwaddch(win2, 1, 1, '2'); + wnoutrefresh(win); + wnoutrefresh(win1); + wnoutrefresh(win2); + doupdate(); + + /**************************************************************** + * Await a keypress to show what we've done so far. * + ****************************************************************/ + getch(); + + /**************************************************************** + * Now, overwrite win2 with contents of all lower windows IN * + * ORDER from the stdscr up... * + ****************************************************************/ + if (overwrite(stdscr, win2) == ERR) + fprintf(stderr, "overwrite(stdscr, win2) failed!\n"); + + touchwin(stdscr); wnoutrefresh(stdscr); + touchwin(win); wnoutrefresh(win); + touchwin(win1); wnoutrefresh(win1); + touchwin(win2); wnoutrefresh(win2); + doupdate(); + + getch(); + if (overwrite(win, win2) == ERR) + fprintf(stderr, "overwrite(win, win2) failed!\n"); + + touchwin(stdscr); wnoutrefresh(stdscr); + touchwin(win); wnoutrefresh(win); + touchwin(win1); wnoutrefresh(win1); + touchwin(win2); wnoutrefresh(win2); + doupdate(); + + getch(); + if (overwrite(win1, win2) == ERR) + fprintf(stderr, "overwrite(win1, win2) failed!\n"); + + /**************************************************************** + * Perform touches, and hidden refreshes on each window. * + * ------------------------------------------------------------ * + * NOTE: If you replace the wnoutrefresh() call with wrefresh()* + * you can see all windows being redrawn untouched. * + ****************************************************************/ + touchwin(stdscr); wnoutrefresh(stdscr); + touchwin(win); wnoutrefresh(win); + touchwin(win1); wnoutrefresh(win1); + touchwin(win2); wnoutrefresh(win2); + doupdate(); + + /**************************************************************** + * At this point, win2 should be "destroyed"; having all other * + * window contents overwritten onto it. The doupdate() should * + * effectively remove it from the screen, leaving the others * + * untouched. On SVR4, this happens, but not with ncurses. * + * I'd suspect something in overwrite() causes this, as nothing * + * appears to be overwritten after the calls, with no errors * + * being reported. This was compiled on my Linux from Slackware* + * 1.1.1, with ncurses1.8.1 recompiled on it, using the console * + * entry from the "new" terminfo from ncurses1.8.1. * + ****************************************************************/ + getch(); + + /**************************************************************** + * Clean up our act and exit. * + ****************************************************************/ + endwin(); +} + diff --git a/lib/libncurses/TESTS/rain.c b/lib/libncurses/TESTS/rain.c new file mode 100644 index 000000000000..83951ae12746 --- /dev/null +++ b/lib/libncurses/TESTS/rain.c @@ -0,0 +1,96 @@ +#include +#include +/* rain 11/3/1980 EPS/CITHEP */ + +#define cursor(col,row) move(row,col) + +float ranf(); +void onsig(); + +main(argc,argv) +int argc; +char *argv[]; +{ +int x, y, j; +static int xpos[5], ypos[5]; +float r; +float c; + + for (j=SIGHUP;j<=SIGTERM;j++) + if (signal(j,SIG_IGN)!=SIG_IGN) signal(j,onsig); + + initscr(); + nl(); + noecho(); + r = (float)(LINES - 4); + c = (float)(COLS - 4); + for (j=5;--j>=0;) { + xpos[j]=(int)(c* ranf())+2; + ypos[j]=(int)(r* ranf())+2; + } + for (j=0;;) { + x=(int)(c*ranf())+2; + y=(int)(r*ranf())+2; + + cursor(x,y); addch('.'); + + cursor(xpos[j],ypos[j]); addch('o'); + + if (j==0) j=4; else --j; + cursor(xpos[j],ypos[j]); addch('O'); + + if (j==0) j=4; else --j; + cursor(xpos[j],ypos[j]-1); + addch('-'); + cursor(xpos[j]-1,ypos[j]); + addstr("|.|"); + cursor(xpos[j],ypos[j]+1); + addch('-'); + + if (j==0) j=4; else --j; + cursor(xpos[j],ypos[j]-2); + addch('-'); + cursor(xpos[j]-1,ypos[j]-1); + addstr("/ \\"); + cursor(xpos[j]-2,ypos[j]); + addstr("| O |"); + cursor(xpos[j]-1,ypos[j]+1); + addstr("\\ /"); + cursor(xpos[j],ypos[j]+2); + addch('-'); + + if (j==0) j=4; else --j; + cursor(xpos[j],ypos[j]-2); + addch(' '); + cursor(xpos[j]-1,ypos[j]-1); + addstr(" "); + cursor(xpos[j]-2,ypos[j]); + addstr(" "); + cursor(xpos[j]-1,ypos[j]+1); + addstr(" "); + cursor(xpos[j],ypos[j]+2); + addch(' '); + xpos[j]=x; ypos[j]=y; + refresh(); + } +} + +void +onsig(n) +int n; +{ + endwin(); + exit(0); +} + +float +ranf() +{ + float rv; + long r = rand(); + + r &= 077777; + rv =((float)r/32767.); + return rv; +} + diff --git a/lib/libncurses/TESTS/scroll.c b/lib/libncurses/TESTS/scroll.c new file mode 100644 index 000000000000..428a064b43b8 --- /dev/null +++ b/lib/libncurses/TESTS/scroll.c @@ -0,0 +1,30 @@ +#include + +main() +{ +int i; + + initscr(); + noecho(); + scrollok(stdscr, TRUE); + setscrreg(0, 9); + mvaddstr(0,0,"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); + mvaddstr(1,0,"bbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); + mvaddstr(2,0,"ccccccccccccccccccccccccccccc"); + mvaddstr(3,0,"ddddddddddddddddddddddddddddd"); + mvaddstr(4,0,"eeeeeeeeeeeeeeeeeeeeeeeeeeeee"); + mvaddstr(5,0,"fffffffffffffffffffffffffffff"); + mvaddstr(6,0,"ggggggggggggggggggggggggggggg"); + mvaddstr(7,0,"hhhhhhhhhhhhhhhhhhhhhhhhhhhhh"); + mvaddstr(8,0,"iiiiiiiiiiiiiiiiiiiiiiiiiiiii"); + mvaddstr(9,0,"jjjjjjjjjjjjjjjjjjjjjjjjjjjjj"); + refresh(); + for (i = 0; i < 4; i++) { + getch(); + scrl(-1); + refresh(); + } + getch(); + endwin(); + +} diff --git a/lib/libncurses/TESTS/scroll2.c b/lib/libncurses/TESTS/scroll2.c new file mode 100644 index 000000000000..53abaa3c3801 --- /dev/null +++ b/lib/libncurses/TESTS/scroll2.c @@ -0,0 +1,91 @@ +#include +#define ROWS 20 +#define scroll_window wscrl + +main() +{ + int i; + WINDOW * w; + + + initscr(); + cbreak(); + noecho(); + w = newwin (ROWS, 35, 2, 25); + scrollok(w, TRUE); + wsetscrreg(w, 0, ROWS-1); + +#ifdef LELE + mvaddstr (0, 0, "With my function"); +#else + mvaddstr (0, 0, "With the original wscrl"); +#endif + refresh(); + + + for (i=0; i + +main(int argc, char **argv) +{ + WINDOW *w, *x; + + initscr(); + w = newwin(0, 0, 0, 0); + if (argc > 2) + x = newwin(0, 0, 0, 0); + scrollok(w, TRUE); + if (argc > 2) + scrollok(x, TRUE); + idlok(w, TRUE); + if (argc > 2) + idlok(x, TRUE); + wmove(w, LINES - 1, 0); + waddstr(w, "test 1 in w"); + wrefresh(w); + sleep(1); + if (argc == 2 || argc == 4) + { + waddch(w, '\n'); + sleep(1); + waddch(w, '\n'); + sleep(1); + waddch(w, '\n'); + sleep(1); + beep(); + wrefresh(w); + } + sleep(1); + if (argc > 2) + { + wmove(x, LINES - 1, 0); + waddstr(x, "test 2 in x"); + sleep(1); + waddch(x, '\n'); + sleep(1); + waddch(x, '\n'); + sleep(1); + waddch(x, '\n'); + sleep(1); + beep(); + wrefresh(w); + sleep(1); + } + endwin(); + return 0; +} + diff --git a/lib/libncurses/TESTS/test.c b/lib/libncurses/TESTS/test.c new file mode 100644 index 000000000000..1fc3e6e9a037 --- /dev/null +++ b/lib/libncurses/TESTS/test.c @@ -0,0 +1,27 @@ + +#include + +main() +{ +int x, y; + + initscr(); + cbreak(); + nodelay(stdscr, TRUE); + + for (y = 0; y < 43; y++) + for (x =0; x < 132; x++) { + move(y,x); + printw("X"); + refresh(); + if (!getch()) { + beep(); + sleep(1); + } + } + + nocbreak(); + endwin(); +} + + diff --git a/lib/libncurses/TESTS/testcurs.c b/lib/libncurses/TESTS/testcurs.c new file mode 100644 index 000000000000..3c92027d84a3 --- /dev/null +++ b/lib/libncurses/TESTS/testcurs.c @@ -0,0 +1,532 @@ +/* + * + * This is a test program for the PDCurses screen package for IBM PC type + * machines. + * This program was written by John Burnell (johnb@kea.am.dsir.govt.nz) + * + */ + +#include +#include + +#ifdef __STDC__ +void inputTest (WINDOW *); +void scrollTest (WINDOW *); +void introTest (WINDOW *); +int initTest (WINDOW **); +void outputTest (WINDOW *); +void padTest (WINDOW *); +void resizeTest (WINDOW *); +void display_menu(int,int); +#else +void inputTest (); +void scrollTest (); +void introTest (); +int initTest (); +void outputTest (); +void padTest (); +void resizeTest (); +void display_menu(); +#endif + +struct commands +{ + char *text; +#ifdef __STDC__ + void (*function)(WINDOW *); +#else + void (*function)(); +#endif +}; +typedef struct commands COMMAND; +#define MAX_OPTIONS 6 +COMMAND command[MAX_OPTIONS] = +{ + {"Intro Test",introTest}, + {"Pad Test",padTest}, + {"Resize Test",resizeTest}, + {"Scroll Test",scrollTest}, + {"Input Test",inputTest}, + {"Output Test",outputTest} +}; + +int width, height; + +main() +{ +WINDOW *win; +int key,old_option=(-1),new_option=0; +bool quit=FALSE; + +#ifdef PDCDEBUG + PDC_debug("testcurs started\n"); +#endif + if (!initTest (&win)) {return 1;} + +#ifdef A_COLOR + if (has_colors()) + { + init_pair(1,COLOR_WHITE,COLOR_BLUE); + wattrset(win, COLOR_PAIR(1)); + } + else + wattrset(win, A_REVERSE); +#else + wattrset(win, A_REVERSE); +#endif + + erase(); + display_menu(old_option,new_option); + while(1) + { + noecho(); + keypad(stdscr,TRUE); + raw(); + key = getch(); + switch(key) + { + case 10: + case 13: + case KEY_ENTER: + erase(); + refresh(); + (*command[new_option].function)(win); + erase(); + display_menu(old_option,new_option); + break; + case KEY_UP: + new_option = (new_option == 0) ? new_option : new_option-1; + display_menu(old_option,new_option); + break; + case KEY_DOWN: + new_option = (new_option == MAX_OPTIONS-1) ? new_option : new_option+1; + display_menu(old_option,new_option); + break; + case 'Q': + case 'q': + quit = TRUE; + break; + default: break; + } + if (quit == TRUE) + break; + } + + delwin (win); + + endwin(); + return 0; +} +#ifdef __STDC__ +void Continue (WINDOW *win) +#else +void Continue (win) +WINDOW *win; +#endif +{ + wmove(win, 10, 1); +/* wclrtoeol(win); +*/ mvwaddstr(win, 10, 1, " Press any key to continue"); + wrefresh(win); + raw(); + wgetch(win); +} +#ifdef __STDC_ +int initTest (WINDOW **win) +#else +int initTest (win) +WINDOW **win; +#endif +{ +#ifdef PDCDEBUG + PDC_debug("initTest called\n"); +#endif + initscr(); +#ifdef PDCDEBUG + PDC_debug("after initscr()\n"); +#endif +#ifdef A_COLOR + if (has_colors()) + start_color(); +#endif + width = 60; + height = 13; /* Create a drawing window */ + *win = newwin(height, width, (LINES-height)/2, (COLS-width)/2); + if(*win == NULL) + { endwin(); + return 1; + } +} +#ifdef __STDC__ +void introTest (WINDOW *win) +#else +void introTest (win) +WINDOW *win; +#endif +{ + beep (); + werase(win); + + box(win, ACS_VLINE, ACS_HLINE); + wrefresh(win); + cbreak (); + mvwaddstr(win, 1, 1, "You should have rectangle in the middle of the screen"); + mvwaddstr(win, 2, 1, "You should have heard a beep"); + Continue(win); + return; +} +#ifdef __STDC__ +void scrollTest (WINDOW *win) +#else +void scrollTest (win) +WINDOW *win; +#endif +{ + int i; + int OldX, OldY; + char *Message = "The window will now scroll slowly"; + + mvwprintw (win, height - 2, 1, Message); + wrefresh (win); + scrollok(win, TRUE); + for (i = 1; i <= height; i++) { + usleep (250); + scroll(win); + wrefresh (win); + }; + + getmaxyx (win, OldY, OldX); + mvwprintw (win, 6, 1, "The top of the window will scroll"); + wmove (win, 1, 1); + wsetscrreg (win, 0, 4); + box(win, ACS_VLINE, ACS_HLINE); + wrefresh (win); + for (i = 1; i <= 5; i++) { + usleep (500); + scroll(win); + wrefresh (win); + }; + wsetscrreg (win, 0, --OldY); + +} +#ifdef __STDC__ +void inputTest (WINDOW *win) +#else +void inputTest (win) +WINDOW *win; +#endif +{ + int w, h, bx, by, sw, sh, i, c,num; + char buffer [80]; + WINDOW *subWin; + wclear (win); + + w = win->_maxx; + h = win->_maxy; + bx = win->_begx; + by = win->_begy; + sw = w / 3; + sh = h / 3; + if((subWin = subwin(win, sh, sw, by + h - sh - 2, bx + w - sw - 2)) == NULL) + return; + +#ifdef A_COLOR + if (has_colors()) + { + init_pair(2,COLOR_CYAN,COLOR_BLUE); + wattrset(subWin, COLOR_PAIR(2) | A_BOLD); + } + else + wattrset(subWin, A_BOLD); +#else + wattrset(subWin, A_BOLD); +#endif + box(subWin, ACS_VLINE, ACS_HLINE); + wrefresh(win); + + nocbreak(); + mvwaddstr(win, 2, 1, "Press some keys for 5 seconds"); + mvwaddstr(win, 1, 1, "Pressing ^C should do nothing"); + wrefresh(win); + + for (i = 0; i < 5; i++) { + werase (subWin); + box(subWin, ACS_VLINE, ACS_HLINE); + mvwprintw (subWin, 1, 1, "Time = %d", i); + wrefresh(subWin); + usleep(1000); + flushinp(); + } + + delwin (subWin); + werase(win); + flash(); + wrefresh(win); + usleep(500); + + mvwaddstr(win, 2, 1, "Press a key, followed by ENTER"); + wmove(win, 9, 10); + wrefresh(win); + echo(); + noraw(); + wgetch(win); + flushinp(); + + wmove(win, 9, 10); + wdelch(win); + mvwaddstr(win, 4, 1, "The character should now have been deleted"); + Continue(win); + + wclear (win); + mvwaddstr(win, 2, 1, "Press a function key or an arrow key"); + wrefresh(win); + keypad(win, TRUE); + raw(); + c = wgetch(win); + + nodelay(win, TRUE); + wgetch(win); + nodelay(win, FALSE); + + refresh(); + wclear (win); + mvwaddstr(win, 3, 2, "The window should have moved"); + mvwaddstr(win, 4, 2, "This text should have appeared without you pressing a key"); + mvwprintw(win, 2, 2, "Keycode = %d", c); + mvwaddstr(win, 6, 2, "Enter a number then a string seperated by space"); + echo(); + noraw(); + mvwscanw(win, 7, 6, "%d %s", &num,buffer); + mvwprintw(win, 8, 6, "String: %s Number: %d", buffer,num); + Continue(win); +} +#ifdef __STDC__ +void outputTest (WINDOW *win) +#else +void outputTest (win) +WINDOW *win; +#endif +{ + WINDOW *win1; + char Buffer [80]; + chtype ch; + + traceon(); + nl (); + wclear (win); + mvwaddstr(win, 1, 1, "You should now have a screen in the upper left corner, and this text should have wrapped"); + mvwin(win, 2, 1); + Continue(win); + + wclear(win); + mvwaddstr(win, 1, 1, "A new window will appear with this text in it"); + mvwaddstr(win, 8, 1, "Press any key to continue"); + wrefresh(win); + wgetch(win); + + win1 = newwin(10, 50, 15, 25); + if(win1 == NULL) + { endwin(); + return; + } +#ifdef A_COLOR + if (has_colors()) + { + init_pair(3,COLOR_BLUE,COLOR_WHITE); + wattrset(win1, COLOR_PAIR(3)); + } + else + wattrset(win1, A_NORMAL); +#else + wattrset(win1, A_NORMAL); +#endif + wclear (win1); + mvwaddstr(win1, 5, 1, "This text should appear; using overlay option"); + copywin(win, win1,0,0,0,0,10,50,TRUE); + +#ifdef UNIX + box(win1,ACS_VLINE,ACS_HLINE); +#else + box(win1,0xb3,0xc4); +#endif + wmove(win1, 8, 26); + wrefresh(win1); + wgetch(win1); + + wclear(win1); + wattron(win1, A_BLINK); + mvwaddstr(win1, 4, 1, "This blinking text should appear in only the second window"); + wattroff(win1, A_BLINK); + wrefresh(win1); + wgetch(win1); + delwin(win1); + + wclear(win); + wrefresh(win); + mvwaddstr(win, 6, 2, "This line shouldn't appear"); + mvwaddstr(win, 4, 2, "Only half of the next line is visible"); + mvwaddstr(win, 5, 2, "Only half of the next line is visible"); + wmove(win, 6, 1); + wclrtobot (win); + wmove(win, 5, 20); + wclrtoeol (win); + mvwaddstr(win, 8, 2, "This line also shouldn't appear"); + wmove(win, 8, 1); + wdeleteln(win); + Continue(win); + traceoff(); + + wmove (win, 5, 9); + ch = winch (win); + + wclear(win); + wmove (win, 6, 2); + waddstr (win, "The next char should be l: "); + winsch (win, ch); + Continue(win); + + wmove(win, 5, 1); + winsertln (win); + mvwaddstr(win, 5, 2, "The lines below should have moved down"); + Continue(win); + + wclear(win); + wmove(win, 2, 2); + wprintw(win, "This is a formatted string in a window: %d %s\n", 42, "is it"); + mvwaddstr(win, 10, 1, "Enter a string: "); + wrefresh(win); + noraw(); + echo(); + wscanw (win, "%s", Buffer); + + wclear(win); + mvwaddstr(win, 10, 1, "Enter a string"); + wrefresh(win); + clear(); + move(0,0); + printw("This is a formatted string in stdscr: %d %s\n", 42, "is it"); + mvaddstr(10, 1, "Enter a string: "); + refresh(); + noraw(); + echo(); + scanw ("%s", Buffer); + + wclear(win); + curs_set(2); + mvwaddstr(win, 1, 1, "The cursor should appear as a block"); + Continue(win); + + wclear(win); + curs_set(0); + mvwaddstr(win, 1, 1, "The cursor should have disappeared"); + Continue(win); + + wclear(win); + curs_set(1); + mvwaddstr(win, 1, 1, "The cursor should be an underline"); + Continue(win); +} + +#ifdef __STDC__ +void resizeTest(WINDOW *dummy) +#else +void resizeTest(dummy) +WINDOW *dummy; +#endif +{ + WINDOW *win1; + char Buffer [80]; + chtype ch; + + savetty (); + + clear(); + refresh(); +#ifdef __PDCURSES__ + resize(50); +#endif + + + win1 = newwin(11, 50, 14, 25); + if(win1 == NULL) + { endwin(); + return; + } +#ifdef A_COLOR + if (has_colors()) + { + init_pair(3,COLOR_BLUE,COLOR_WHITE); + wattrset(win1, COLOR_PAIR(3)); + } +#endif + wclear (win1); + + mvwaddstr(win1, 1, 1, "The screen may now have 50 lines"); + Continue(win1); + + resetty (); + + wclear (win1); + mvwaddstr(win1, 1, 1, "The screen should now be reset"); + Continue(win1); + + delwin(win1); + + clear(); + refresh(); + +} +#ifdef __STDC__ +void padTest(WINDOW *dummy) +#else +void padTest(dummy) +WINDOW *dummy; +#endif +{ +WINDOW *pad; + + pad = newpad(50,100); + mvwaddstr(pad, 5, 2, "This is a new pad"); + mvwaddstr(pad, 8, 0, "The end of this line should be truncated here:abcd"); + mvwaddstr(pad,11, 1, "This line should not appear."); + wmove(pad, 10, 1); + wclrtoeol(pad); + mvwaddstr(pad, 10, 1, " Press any key to continue"); + prefresh(pad,0,0,0,0,10,45); + keypad(pad, TRUE); + raw(); + wgetch(pad); + + mvwaddstr(pad, 35, 2, "This is displayed at line 35 in the pad"); + mvwaddstr(pad, 40, 1, " Press any key to continue"); + prefresh(pad,30,0,0,0,10,45); + keypad(pad, TRUE); + raw(); + wgetch(pad); + + delwin(pad); +} + +#ifdef __STDC__ +void display_menu(int old_option,int new_option) +#else +void display_menu(old_option,new_option) +int old_option,new_option; +#endif +{ + register int i; + + attrset(A_NORMAL); + mvaddstr(3,20,"PDCurses Test Program"); + + for (i=0;i +#include + +#define cursor(col,row) move(row,col) + +int Wrap; +short *ref[128]; +static char flavor[]={ + 'O', '*', '#', '$', '%', '0' +}; +static short xinc[]={ + 1, 1, 1, 0, -1, -1, -1, 0 +}, yinc[]={ + -1, 0, 1, 1, 1, 0, -1, -1 +}; +static struct worm { + int orientation, head; + short *xpos, *ypos; +} worm[40]; +static char *field; +static int length=16, number=3, trail=' '; +static struct options { + int nopts; + int opts[3]; +} normal[8]={ + { 3, { 7, 0, 1 } }, + { 3, { 0, 1, 2 } }, + { 3, { 1, 2, 3 } }, + { 3, { 2, 3, 4 } }, + { 3, { 3, 4, 5 } }, + { 3, { 4, 5, 6 } }, + { 3, { 5, 6, 7 } }, + { 3, { 6, 7, 0 } } +}, upper[8]={ + { 1, { 1, 0, 0 } }, + { 2, { 1, 2, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 2, { 4, 5, 0 } }, + { 1, { 5, 0, 0 } }, + { 2, { 1, 5, 0 } } +}, left[8]={ + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 2, { 2, 3, 0 } }, + { 1, { 3, 0, 0 } }, + { 2, { 3, 7, 0 } }, + { 1, { 7, 0, 0 } }, + { 2, { 7, 0, 0 } } +}, right[8]={ + { 1, { 7, 0, 0 } }, + { 2, { 3, 7, 0 } }, + { 1, { 3, 0, 0 } }, + { 2, { 3, 4, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 2, { 6, 7, 0 } } +}, lower[8]={ + { 0, { 0, 0, 0 } }, + { 2, { 0, 1, 0 } }, + { 1, { 1, 0, 0 } }, + { 2, { 1, 5, 0 } }, + { 1, { 5, 0, 0 } }, + { 2, { 5, 6, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } } +}, upleft[8]={ + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 1, { 3, 0, 0 } }, + { 2, { 1, 3, 0 } }, + { 1, { 1, 0, 0 } } +}, upright[8]={ + { 2, { 3, 5, 0 } }, + { 1, { 3, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 1, { 5, 0, 0 } } +}, lowleft[8]={ + { 3, { 7, 0, 1 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 1, { 1, 0, 0 } }, + { 2, { 1, 7, 0 } }, + { 1, { 7, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } } +}, lowright[8]={ + { 0, { 0, 0, 0 } }, + { 1, { 7, 0, 0 } }, + { 2, { 5, 7, 0 } }, + { 1, { 5, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } }, + { 0, { 0, 0, 0 } } +}; + +void onsig(); +float ranf(); + +main(argc,argv) +int argc; +char *argv[]; +{ +int x, y; +int n; +struct worm *w; +struct options *op; +int h; +short *ip; +int last, bottom; + + for (x=1;x1024) { + fprintf(stderr,"%s: Invalid length\n",*argv); + exit(1); + } + break; + case 'n': + if (++x==argc) goto usage; + if ((number=atoi(argv[x]))<1||number>40) { + fprintf(stderr,"%s: Invalid number of worms\n",*argv); + exit(1); + } + break; + case 't': + trail='.'; + break; + default: + usage: + fprintf(stderr, "usage: %s [-field] [-length #] [-number #] [-trail]\n",*argv); + exit(1); + break; + } + } + + signal(SIGINT, onsig); + initscr(); + bottom = LINES-1; + last = COLS-1; + + ip=(short *)malloc(LINES*COLS*sizeof (short)); + + for (n=0;n=0;) *ip++=0; + ref[bottom][last]=1; + for (n=number, w= &worm[0];--n>=0;w++) { + w->orientation=w->head=0; + if (!(ip=(short *)malloc(length*sizeof (short)))) { + fprintf(stderr,"%s: out of memory\n",*argv); + exit(1); + } + w->xpos=ip; + for (x=length;--x>=0;) *ip++ = -1; + if (!(ip=(short *)malloc(length*sizeof (short)))) { + fprintf(stderr,"%s: out of memory\n",*argv); + exit(1); + } + w->ypos=ip; + for (y=length;--y>=0;) *ip++ = -1; + } + if (field) { + register char *p; + p=field; + for (y=bottom;--y>=0;) { + for (x=COLS;--x>=0;) { + addch(*p++); + if (!*p) p=field; + } + addch('\n'); + } + } + refresh(); + + for (;;) { + for (n=0,w= &worm[0];nxpos[h=w->head])<0) { + cursor(x=w->xpos[h]=0,y=w->ypos[h]=bottom); + addch(flavor[n%6]); + ref[y][x]++; + } + else y=w->ypos[h]; + if (++h==length) h=0; + if (w->xpos[w->head=h]>=0) { + register int x1, y1; + x1=w->xpos[h]; y1=w->ypos[h]; + if (--ref[y1][x1]==0) { + cursor(x1,y1); addch(trail); + } + } + op= &(x==0 ? (y==0 ? upleft : (y==bottom ? lowleft : left)) : + (x==last ? (y==0 ? upright : (y==bottom ? lowright : right)) : + (y==0 ? upper : (y==bottom ? lower : normal))))[w->orientation]; + switch (op->nopts) { + case 0: + refresh(); + endwin(); + exit(0); + case 1: + w->orientation=op->opts[0]; + break; + default: + w->orientation=op->opts[(int)(ranf()*(float)op->nopts)]; + } + cursor(x+=xinc[w->orientation], y+=yinc[w->orientation]); + if (!Wrap||x!=last||y!=bottom) addch(flavor[n%6]); + ref[w->ypos[h]=y][w->xpos[h]=x]++; + } + refresh(); + } +} + +void +onsig() +{ + endwin(); + exit(0); +} + +float +ranf() +{ +float rv; +long r = rand(); + + r &= 077777; + rv =((float)r/32767.); + return rv; +} diff --git a/lib/libncurses/TESTS/xmas.c b/lib/libncurses/TESTS/xmas.c new file mode 100644 index 000000000000..57cc0ea6bb42 --- /dev/null +++ b/lib/libncurses/TESTS/xmas.c @@ -0,0 +1,1192 @@ +/******************************************************************************/ +/* asciixmas */ +/* December 1989 Larry Bartz Indianapolis, IN */ +/* */ +/* */ +/* I'm dreaming of an ascii character-based monochrome Christmas, */ +/* Just like the one's I used to know! */ +/* Via a full duplex communications channel, */ +/* At 9600 bits per second, */ +/* Even though it's kinda slow. */ +/* */ +/* I'm dreaming of an ascii character-based monochrome Christmas, */ +/* With ev'ry C program I write! */ +/* May your screen be merry and bright! */ +/* And may all your Christmases be amber or green, */ +/* (for reduced eyestrain and improved visibility)! */ +/* */ +/* */ +/* */ +/* */ +/* */ +/* IMPLEMENTATION */ +/* */ +/* Feel free to modify the defined string FROMWHO to reflect you, your */ +/* organization, your site, whatever. */ +/* */ +/* This really looks a lot better if you can turn off your cursor before */ +/* execution. I wanted to do that here but very few termcap entries or */ +/* terminfo definitions have the appropriate string defined. If you know */ +/* the string(s) for the terminal(s) you use or which your site supports, */ +/* you could call asciixmas from within a shell in which you issue the */ +/* string to the terminal. The cursor is distracting but it doesn't really */ +/* ruin the show. */ +/* */ +/* At our site, we invoke this for our users just after login and the */ +/* determination of terminal type. */ +/* */ +/* */ +/* PORTABILITY */ +/* */ +/* I wrote this using only the very simplest curses functions so that it */ +/* might be the most portable. I was personally able to test on five */ +/* different cpu/UNIX combinations. */ +/* */ +/* */ +/* COMPILE */ +/* */ +/* usually this: */ +/* */ +/* cc -O asciixmas.c -lcurses -o asciixmas -s */ +/* */ +/* */ +/* Zilog S8000 models 11, 21, 31, etc with ZEUS variant of SYSTEM III */ +/* maybe other SYSTEM III also: */ +/* */ +/* cc asciixmas.c -lcurses -ltermlib -o asciixmas -s */ +/* */ +/* as above with optional "peephole optimizer" installed: */ +/* */ +/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s */ +/* */ +/* */ +/* Zilog S8000 models 32, 130 with WE32100 chip and SYS V, REL2 */ +/* maybe 3B2 also? */ +/* */ +/* cc -f -O -K sd asciixmas.c -lcurses -o asciixmas -s */ +/* */ +/* */ +/* Pyramid, Sequent, any other "dual universe" types compile and execute */ +/* under either universe. The compile line for the ucb universe (as you */ +/* might expect) is the same as for SYS III UNIX: */ +/* */ +/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s */ +/* */ +/* The above compile will also hold true for other BSD systems. (I hope) */ +/* */ +/* */ +/* */ +/* */ +/* For the Scrooges out there among you who don't want this thing to loop */ +/* forever (or until the user hits a key), insert this into your compile */ +/* line just after "cc" : */ +/* */ +/* -DNOLOOP */ +/* */ +/* like so: */ +/* */ +/* cc -DNOLOOP -O asciixmas.c -lcurses -o asciixmas -s */ +/* */ +/* */ +/* */ +/******************************************************************************/ + +#include +#include + +#define FROMWHO "Mark Hessling - (M.Hessling@gu.edu.au)" + +int y_pos, x_pos; + +WINDOW + *treescrn, *treescrn2,*treescrn3, *treescrn4,*treescrn5, *treescrn6, + *treescrn7, *treescrn8, + *dotdeer0, + *stardeer0, + *lildeer0, *lildeer1, *lildeer2, *lildeer3, + *middeer0, *middeer1, *middeer2, *middeer3, + *bigdeer0, *bigdeer1, *bigdeer2, *bigdeer3, *bigdeer4, + *lookdeer0, *lookdeer1, *lookdeer2, *lookdeer3, *lookdeer4, + *w_holiday, + *w_del_msg; + +void main() +{ + void done(); + int loopy; + + initscr(); + noecho(); + nonl(); + refresh(); + signal(SIGINT,done); + signal(SIGTERM,done); +#if !defined DOS && !defined OS2 + signal(SIGHUP,done); + signal(SIGQUIT,done); +#endif + + + + treescrn = newwin(16,27,3,53); + treescrn2 = newwin(16,27,3,53); + treescrn3 = newwin(16,27,3,53); + treescrn4 = newwin(16,27,3,53); + treescrn5 = newwin(16,27,3,53); + treescrn6 = newwin(16,27,3,53); + treescrn7 = newwin(16,27,3,53); + treescrn8 = newwin(16,27,3,53); + + dotdeer0 = newwin(3,71,0,8); + + stardeer0 = newwin(4,56,0,8); + + lildeer0 = newwin(7,53,0,8); + lildeer1 = newwin(2,4,0,0); + lildeer2 = newwin(2,4,0,0); + lildeer3 = newwin(2,4,0,0); + + middeer0 = newwin(15,42,0,8); + middeer1 = newwin(3,7,0,0); + middeer2 = newwin(3,7,0,0); + middeer3 = newwin(3,7,0,0); + + bigdeer0 = newwin(10,23,0,0); + bigdeer1 = newwin(10,23,0,0); + bigdeer2 = newwin(10,23,0,0); + bigdeer3 = newwin(10,23,0,0); + bigdeer4 = newwin(10,23,0,0); + + lookdeer0 = newwin(10,25,0,0); + lookdeer1 = newwin(10,25,0,0); + lookdeer2 = newwin(10,25,0,0); + lookdeer3 = newwin(10,25,0,0); + lookdeer4 = newwin(10,25,0,0); + + w_holiday = newwin(1,26,3,27); + + w_del_msg = newwin(1,12,23,60); + + mvwaddstr(w_del_msg,0,0,"Hit any key to quit"); + + mvwaddstr(w_holiday,0,0,"H A P P Y H O L I D A Y S"); + + /* set up the windows for our various reindeer */ + + /* lildeer1 */ + mvwaddch(lildeer1,0,0,(chtype)'V'); + mvwaddch(lildeer1,1,0,(chtype)'@'); + mvwaddch(lildeer1,1,1,(chtype)'<'); + mvwaddch(lildeer1,1,2,(chtype)'>'); + mvwaddch(lildeer1,1,3,(chtype)'~'); + + /* lildeer2 */ + mvwaddch(lildeer2,0,0,(chtype)'V'); + mvwaddch(lildeer2,1,0,(chtype)'@'); + mvwaddch(lildeer2,1,1,(chtype)'|'); + mvwaddch(lildeer2,1,2,(chtype)'|'); + mvwaddch(lildeer2,1,3,(chtype)'~'); + + /* lildeer3 */ + mvwaddch(lildeer3,0,0,(chtype)'V'); + mvwaddch(lildeer3,1,0,(chtype)'@'); + mvwaddch(lildeer3,1,1,(chtype)'>'); + mvwaddch(lildeer3,1,2,(chtype)'<'); + mvwaddch(lildeer2,1,3,(chtype)'~'); + + + /* middeer1 */ + mvwaddch(middeer1,0,2,(chtype)'y'); + mvwaddch(middeer1,0,3,(chtype)'y'); + mvwaddch(middeer1,1,2,(chtype)'0'); + mvwaddch(middeer1,1,3,(chtype)'('); + mvwaddch(middeer1,1,4,(chtype)'='); + mvwaddch(middeer1,1,5,(chtype)')'); + mvwaddch(middeer1,1,6,(chtype)'~'); + mvwaddch(middeer1,2,3,(chtype)'\\'); + mvwaddch(middeer1,2,4,(chtype)'/'); + + /* middeer2 */ + mvwaddch(middeer2,0,2,(chtype)'y'); + mvwaddch(middeer2,0,3,(chtype)'y'); + mvwaddch(middeer2,1,2,(chtype)'0'); + mvwaddch(middeer2,1,3,(chtype)'('); + mvwaddch(middeer2,1,4,(chtype)'='); + mvwaddch(middeer2,1,5,(chtype)')'); + mvwaddch(middeer2,1,6,(chtype)'~'); + mvwaddch(middeer2,2,3,(chtype)'|'); + mvwaddch(middeer2,2,5,(chtype)'|'); + + /* middeer3 */ + mvwaddch(middeer3,0,2,(chtype)'y'); + mvwaddch(middeer3,0,3,(chtype)'y'); + mvwaddch(middeer3,1,2,(chtype)'0'); + mvwaddch(middeer3,1,3,(chtype)'('); + mvwaddch(middeer3,1,4,(chtype)'='); + mvwaddch(middeer3,1,5,(chtype)')'); + mvwaddch(middeer3,1,6,(chtype)'~'); + mvwaddch(middeer3,2,2,(chtype)'/'); + mvwaddch(middeer3,2,6,(chtype)'\\'); + + + /* bigdeer1 */ + mvwaddch(bigdeer1,0,17,(chtype)'\\'); + mvwaddch(bigdeer1,0,18,(chtype)'/'); + mvwaddch(bigdeer1,0,20,(chtype)'\\'); + mvwaddch(bigdeer1,0,21,(chtype)'/'); + mvwaddch(bigdeer1,1,18,(chtype)'\\'); + mvwaddch(bigdeer1,1,20,(chtype)'/'); + mvwaddch(bigdeer1,2,19,(chtype)'|'); + mvwaddch(bigdeer1,2,20,(chtype)'_'); + mvwaddch(bigdeer1,3,18,(chtype)'/'); + mvwaddch(bigdeer1,3,19,(chtype)'^'); + mvwaddch(bigdeer1,3,20,(chtype)'0'); + mvwaddch(bigdeer1,3,21,(chtype)'\\'); + mvwaddch(bigdeer1,4,17,(chtype)'/'); + mvwaddch(bigdeer1,4,18,(chtype)'/'); + mvwaddch(bigdeer1,4,19,(chtype)'\\'); + mvwaddch(bigdeer1,4,22,(chtype)'\\'); + mvwaddstr(bigdeer1,5,7,"^~~~~~~~~// ~~U"); + mvwaddstr(bigdeer1,6,7,"( \\_____( /"); + mvwaddstr(bigdeer1,7,8,"( ) /"); + mvwaddstr(bigdeer1,8,9,"\\\\ /"); + mvwaddstr(bigdeer1,9,11,"\\>/>"); + + /* bigdeer2 */ + mvwaddch(bigdeer2,0,17,(chtype)'\\'); + mvwaddch(bigdeer2,0,18,(chtype)'/'); + mvwaddch(bigdeer2,0,20,(chtype)'\\'); + mvwaddch(bigdeer2,0,21,(chtype)'/'); + mvwaddch(bigdeer2,1,18,(chtype)'\\'); + mvwaddch(bigdeer2,1,20,(chtype)'/'); + mvwaddch(bigdeer2,2,19,(chtype)'|'); + mvwaddch(bigdeer2,2,20,(chtype)'_'); + mvwaddch(bigdeer2,3,18,(chtype)'/'); + mvwaddch(bigdeer2,3,19,(chtype)'^'); + mvwaddch(bigdeer2,3,20,(chtype)'0'); + mvwaddch(bigdeer2,3,21,(chtype)'\\'); + mvwaddch(bigdeer2,4,17,(chtype)'/'); + mvwaddch(bigdeer2,4,18,(chtype)'/'); + mvwaddch(bigdeer2,4,19,(chtype)'\\'); + mvwaddch(bigdeer2,4,22,(chtype)'\\'); + mvwaddstr(bigdeer2,5,7,"^~~~~~~~~// ~~U"); + mvwaddstr(bigdeer2,6,7,"(( )____( /"); + mvwaddstr(bigdeer2,7,7,"( / |"); + mvwaddstr(bigdeer2,8,8,"\\/ |"); + mvwaddstr(bigdeer2,9,9,"|> |>"); + + /* bigdeer3 */ + mvwaddch(bigdeer3,0,17,(chtype)'\\'); + mvwaddch(bigdeer3,0,18,(chtype)'/'); + mvwaddch(bigdeer3,0,20,(chtype)'\\'); + mvwaddch(bigdeer3,0,21,(chtype)'/'); + mvwaddch(bigdeer3,1,18,(chtype)'\\'); + mvwaddch(bigdeer3,1,20,(chtype)'/'); + mvwaddch(bigdeer3,2,19,(chtype)'|'); + mvwaddch(bigdeer3,2,20,(chtype)'_'); + mvwaddch(bigdeer3,3,18,(chtype)'/'); + mvwaddch(bigdeer3,3,19,(chtype)'^'); + mvwaddch(bigdeer3,3,20,(chtype)'0'); + mvwaddch(bigdeer3,3,21,(chtype)'\\'); + mvwaddch(bigdeer3,4,17,(chtype)'/'); + mvwaddch(bigdeer3,4,18,(chtype)'/'); + mvwaddch(bigdeer3,4,19,(chtype)'\\'); + mvwaddch(bigdeer3,4,22,(chtype)'\\'); + mvwaddstr(bigdeer3,5,7,"^~~~~~~~~// ~~U"); + mvwaddstr(bigdeer3,6,6,"( ()_____( /"); + mvwaddstr(bigdeer3,7,6,"/ / /"); + mvwaddstr(bigdeer3,8,5,"|/ \\"); + mvwaddstr(bigdeer3,9,5,"/> \\>"); + + /* bigdeer4 */ + mvwaddch(bigdeer4,0,17,(chtype)'\\'); + mvwaddch(bigdeer4,0,18,(chtype)'/'); + mvwaddch(bigdeer4,0,20,(chtype)'\\'); + mvwaddch(bigdeer4,0,21,(chtype)'/'); + mvwaddch(bigdeer4,1,18,(chtype)'\\'); + mvwaddch(bigdeer4,1,20,(chtype)'/'); + mvwaddch(bigdeer4,2,19,(chtype)'|'); + mvwaddch(bigdeer4,2,20,(chtype)'_'); + mvwaddch(bigdeer4,3,18,(chtype)'/'); + mvwaddch(bigdeer4,3,19,(chtype)'^'); + mvwaddch(bigdeer4,3,20,(chtype)'0'); + mvwaddch(bigdeer4,3,21,(chtype)'\\'); + mvwaddch(bigdeer4,4,17,(chtype)'/'); + mvwaddch(bigdeer4,4,18,(chtype)'/'); + mvwaddch(bigdeer4,4,19,(chtype)'\\'); + mvwaddch(bigdeer4,4,22,(chtype)'\\'); + mvwaddstr(bigdeer4,5,7,"^~~~~~~~~// ~~U"); + mvwaddstr(bigdeer4,6,6,"( )______( /"); + mvwaddstr(bigdeer4,7,5,"(/ \\"); + mvwaddstr(bigdeer4,8,0,"v___= ----^"); + + + /* lookdeer1 */ + mvwaddstr(lookdeer1,0,16,"\\/ \\/"); + mvwaddstr(lookdeer1,1,17,"\\Y/ \\Y/"); + mvwaddstr(lookdeer1,2,19,"\\=/"); + mvwaddstr(lookdeer1,3,17,"^\\o o/^"); + mvwaddstr(lookdeer1,4,17,"//( )"); + mvwaddstr(lookdeer1,5,7,"^~~~~~~~~// \\O/"); + mvwaddstr(lookdeer1,6,7,"( \\_____( /"); + mvwaddstr(lookdeer1,7,8,"( ) /"); + mvwaddstr(lookdeer1,8,9,"\\\\ /"); + mvwaddstr(lookdeer1,9,11,"\\>/>"); + + /* lookdeer2 */ + mvwaddstr(lookdeer2,0,16,"\\/ \\/"); + mvwaddstr(lookdeer2,1,17,"\\Y/ \\Y/"); + mvwaddstr(lookdeer2,2,19,"\\=/"); + mvwaddstr(lookdeer2,3,17,"^\\o o/^"); + mvwaddstr(lookdeer2,4,17,"//( )"); + mvwaddstr(lookdeer2,5,7,"^~~~~~~~~// \\O/"); + mvwaddstr(lookdeer2,6,7,"(( )____( /"); + mvwaddstr(lookdeer2,7,7,"( / |"); + mvwaddstr(lookdeer2,8,8,"\\/ |"); + mvwaddstr(lookdeer2,9,9,"|> |>"); + + /* lookdeer3 */ + mvwaddstr(lookdeer3,0,16,"\\/ \\/"); + mvwaddstr(lookdeer3,1,17,"\\Y/ \\Y/"); + mvwaddstr(lookdeer3,2,19,"\\=/"); + mvwaddstr(lookdeer3,3,17,"^\\o o/^"); + mvwaddstr(lookdeer3,4,17,"//( )"); + mvwaddstr(lookdeer3,5,7,"^~~~~~~~~// \\O/"); + mvwaddstr(lookdeer3,6,6,"( ()_____( /"); + mvwaddstr(lookdeer3,7,6,"/ / /"); + mvwaddstr(lookdeer3,8,5,"|/ \\"); + mvwaddstr(lookdeer3,9,5,"/> \\>"); + + /* lookdeer4 */ + mvwaddstr(lookdeer4,0,16,"\\/ \\/"); + mvwaddstr(lookdeer4,1,17,"\\Y/ \\Y/"); + mvwaddstr(lookdeer4,2,19,"\\=/"); + mvwaddstr(lookdeer4,3,17,"^\\o o/^"); + mvwaddstr(lookdeer4,4,17,"//( )"); + mvwaddstr(lookdeer4,5,7,"^~~~~~~~~// \\O/"); + mvwaddstr(lookdeer4,6,6,"( )______( /"); + mvwaddstr(lookdeer4,7,5,"(/ \\"); + mvwaddstr(lookdeer4,8,0,"v___= ----^"); + + + + /***********************************************/ + cbreak(); + nodelay(stdscr,TRUE); + do + { + clear(); + werase(treescrn); + touchwin(treescrn); + werase(treescrn2); + touchwin(treescrn2); + werase(treescrn8); + touchwin(treescrn8); + refresh(); + usleep(1000); + boxit(); + refresh(); + usleep(1000); + seas(); + refresh(); + usleep(1000); + greet(); + refresh(); + usleep(1000); + fromwho(); + refresh(); + usleep(1000); + tree(); + usleep(1000); + balls(); + usleep(1000); + star(); + usleep(1000); + strng1(); + strng2(); + strng3(); + strng4(); + strng5(); + + + /* set up the windows for our blinking trees */ + /* **************************************** */ + /* treescrn3 */ + + overlay(treescrn, treescrn3); + + /*balls*/ + mvwaddch(treescrn3, 4, 18, ' '); + mvwaddch(treescrn3, 7, 6, ' '); + mvwaddch(treescrn3, 8, 19, ' '); + mvwaddch(treescrn3, 11, 22, ' '); + + /*star*/ + mvwaddch(treescrn3, 0, 12, '*'); + + /*strng1*/ + mvwaddch(treescrn3, 3, 11, ' '); + + /*strng2*/ + mvwaddch(treescrn3, 5, 13, ' '); + mvwaddch(treescrn3, 6, 10, ' '); + + /*strng3*/ + mvwaddch(treescrn3, 7, 16, ' '); + mvwaddch(treescrn3, 7, 14, ' '); + + /*strng4*/ + mvwaddch(treescrn3, 10, 13, ' '); + mvwaddch(treescrn3, 10, 10, ' '); + mvwaddch(treescrn3, 11, 8, ' '); + + /*strng5*/ + mvwaddch(treescrn3, 11, 18, ' '); + mvwaddch(treescrn3, 12, 13, ' '); + + + /* treescrn4 */ + + overlay(treescrn, treescrn4); + + /*balls*/ + mvwaddch(treescrn4, 3, 9, ' '); + mvwaddch(treescrn4, 4, 16, ' '); + mvwaddch(treescrn4, 7, 6, ' '); + mvwaddch(treescrn4, 8, 19, ' '); + mvwaddch(treescrn4, 11, 2, ' '); + mvwaddch(treescrn4, 12, 23, ' '); + + /*star*/ + wstandout(treescrn4); + mvwaddch(treescrn4, 0, 12, '*'); + wstandend(treescrn4); + + /*strng1*/ + mvwaddch(treescrn4, 3, 13, ' '); + + /*strng2*/ + + /*strng3*/ + mvwaddch(treescrn4, 7, 15, ' '); + mvwaddch(treescrn4, 8, 11, ' '); + + /*strng4*/ + mvwaddch(treescrn4, 9, 16, ' '); + mvwaddch(treescrn4, 10, 12, ' '); + mvwaddch(treescrn4, 11, 8, ' '); + + /*strng5*/ + mvwaddch(treescrn4, 11, 18, ' '); + mvwaddch(treescrn4, 12, 14, ' '); + + + /* treescrn5 */ + + overlay(treescrn, treescrn5); + + /*balls*/ + mvwaddch(treescrn5, 3, 15, ' '); + mvwaddch(treescrn5, 10, 20, ' '); + mvwaddch(treescrn5, 12, 1, ' '); + + /*star*/ + mvwaddch(treescrn5, 0, 12, '*'); + + /*strng1*/ + mvwaddch(treescrn5, 3, 11, ' '); + + /*strng2*/ + mvwaddch(treescrn5, 5, 12, ' '); + + /*strng3*/ + mvwaddch(treescrn5, 7, 14, ' '); + mvwaddch(treescrn5, 8, 10, ' '); + + /*strng4*/ + mvwaddch(treescrn5, 9, 15, ' '); + mvwaddch(treescrn5, 10, 11, ' '); + mvwaddch(treescrn5, 11, 7, ' '); + + /*strng5*/ + mvwaddch(treescrn5, 11, 17, ' '); + mvwaddch(treescrn5, 12, 13, ' '); + + /* treescrn6 */ + + overlay(treescrn, treescrn6); + + /*balls*/ + mvwaddch(treescrn6, 6, 7, ' '); + mvwaddch(treescrn6, 7, 18, ' '); + mvwaddch(treescrn6, 10, 4, ' '); + mvwaddch(treescrn6, 11, 23, ' '); + + /*star*/ + wstandout(treescrn6); + mvwaddch(treescrn6, 0, 12, '*'); + wstandend(treescrn6); + + /*strng1*/ + + /*strng2*/ + mvwaddch(treescrn6, 5, 11, ' '); + + /*strng3*/ + mvwaddch(treescrn6, 7, 13, ' '); + mvwaddch(treescrn6, 8, 9, ' '); + + /*strng4*/ + mvwaddch(treescrn6, 9, 14, ' '); + mvwaddch(treescrn6, 10, 10, ' '); + mvwaddch(treescrn6, 11, 6, ' '); + + /*strng5*/ + mvwaddch(treescrn6, 11, 16, ' '); + mvwaddch(treescrn6, 12, 12, ' '); + + /* treescrn7 */ + + overlay(treescrn, treescrn7); + + /*balls*/ + mvwaddch(treescrn7, 3, 15, ' '); + mvwaddch(treescrn7, 6, 7, ' '); + mvwaddch(treescrn7, 7, 18, ' '); + mvwaddch(treescrn7, 10, 4, ' '); + mvwaddch(treescrn7, 11, 22, ' '); + + /*star*/ + mvwaddch(treescrn7, 0, 12, '*'); + + /*strng1*/ + mvwaddch(treescrn7, 3, 12, ' '); + + /*strng2*/ + mvwaddch(treescrn7, 5, 13, ' '); + mvwaddch(treescrn7, 6, 9, ' '); + + /*strng3*/ + mvwaddch(treescrn7, 7, 15, ' '); + mvwaddch(treescrn7, 8, 11, ' '); + + /*strng4*/ + mvwaddch(treescrn7, 9, 16, ' '); + mvwaddch(treescrn7, 10, 12, ' '); + mvwaddch(treescrn7, 11, 8, ' '); + + /*strng5*/ + mvwaddch(treescrn7, 11, 18, ' '); + mvwaddch(treescrn7, 12, 14, ' '); + + + usleep(1000); + reindeer(); + + touchwin(w_holiday); + wrefresh(w_holiday); + wrefresh(w_del_msg); + + usleep(1000); + for(loopy = 0;loopy < 100;loopy++) + { + blinkit(); + } + +#ifdef NOLOOP + done(); +#endif + + } + while(getch() == (ERR)); +/* while(!typeahead(stdin));*/ + done(); +} + +boxit() +{ + int x = 0; + + while(x < 20) + { + mvaddch(x, 7, '|'); + ++x; + } + + x = 8; + + while(x < 80) + { + mvaddch(19, x, '_'); + ++x; + } + + x = 0; + + while(x < 80) + { + mvaddch(22, x, '_'); + ++x; + } + + return( 0 ); +} + +seas() +{ + mvaddch(4, 1, 'S'); + mvaddch(6, 1, 'E'); + mvaddch(8, 1, 'A'); + mvaddch(10, 1, 'S'); + mvaddch(12, 1, 'O'); + mvaddch(14, 1, 'N'); + mvaddch(16, 1, '`'); + mvaddch(18, 1, 'S'); + + return( 0 ); +} + + +greet() +{ + mvaddch(3, 5, 'G'); + mvaddch(5, 5, 'R'); + mvaddch(7, 5, 'E'); + mvaddch(9, 5, 'E'); + mvaddch(11, 5, 'T'); + mvaddch(13, 5, 'I'); + mvaddch(15, 5, 'N'); + mvaddch(17, 5, 'G'); + mvaddch(19, 5, 'S'); + + return( 0 ); +} + + +fromwho() +{ + mvaddstr(21, 13, FROMWHO); + return( 0 ); +} + + +del_msg() +{ + mvwaddstr(w_del_msg, 0, 0, "Hit any key to quit"); + wrefresh(w_del_msg); + + refresh(); + + return( 0 ); +} + + +tree() +{ + mvwaddch(treescrn, 1, 11, (chtype)'/'); + mvwaddch(treescrn, 2, 11, (chtype)'/'); + mvwaddch(treescrn, 3, 10, (chtype)'/'); + mvwaddch(treescrn, 4, 9, (chtype)'/'); + mvwaddch(treescrn, 5, 9, (chtype)'/'); + mvwaddch(treescrn, 6, 8, (chtype)'/'); + mvwaddch(treescrn, 7, 7, (chtype)'/'); + mvwaddch(treescrn, 8, 6, (chtype)'/'); + mvwaddch(treescrn, 9, 6, (chtype)'/'); + mvwaddch(treescrn, 10, 5, (chtype)'/'); + mvwaddch(treescrn, 11, 3, (chtype)'/'); + mvwaddch(treescrn, 12, 2, (chtype)'/'); + + mvwaddch(treescrn, 1, 13, (chtype)'\\'); + mvwaddch(treescrn, 2, 13, (chtype)'\\'); + mvwaddch(treescrn, 3, 14, (chtype)'\\'); + mvwaddch(treescrn, 4, 15, (chtype)'\\'); + mvwaddch(treescrn, 5, 15, (chtype)'\\'); + mvwaddch(treescrn, 6, 16, (chtype)'\\'); + mvwaddch(treescrn, 7, 17, (chtype)'\\'); + mvwaddch(treescrn, 8, 18, (chtype)'\\'); + mvwaddch(treescrn, 9, 18, (chtype)'\\'); + mvwaddch(treescrn, 10, 19, (chtype)'\\'); + mvwaddch(treescrn, 11, 21, (chtype)'\\'); + mvwaddch(treescrn, 12, 22, (chtype)'\\'); + + mvwaddch(treescrn, 4, 10, (chtype)'_'); + mvwaddch(treescrn, 4, 14, (chtype)'_'); + mvwaddch(treescrn, 8, 7, (chtype)'_'); + mvwaddch(treescrn, 8, 17, (chtype)'_'); + + mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\"); + + mvwaddstr(treescrn, 14, 11, "| |"); + mvwaddstr(treescrn, 15, 11, "|_|"); + + wrefresh(treescrn); + wrefresh(w_del_msg); + + return( 0 ); +} + + +balls() +{ + + overlay(treescrn, treescrn2); + + mvwaddch(treescrn2, 3, 9, (chtype)'@'); + mvwaddch(treescrn2, 3, 15, (chtype)'@'); + mvwaddch(treescrn2, 4, 8, (chtype)'@'); + mvwaddch(treescrn2, 4, 16, (chtype)'@'); + mvwaddch(treescrn2, 5, 7, (chtype)'@'); + mvwaddch(treescrn2, 5, 17, (chtype)'@'); + mvwaddch(treescrn2, 7, 6, (chtype)'@'); + mvwaddch(treescrn2, 7, 18, (chtype)'@'); + mvwaddch(treescrn2, 8, 5, (chtype)'@'); + mvwaddch(treescrn2, 8, 19, (chtype)'@'); + mvwaddch(treescrn2, 10, 4, (chtype)'@'); + mvwaddch(treescrn2, 10, 20, (chtype)'@'); + mvwaddch(treescrn2, 11, 2, (chtype)'@'); + mvwaddch(treescrn2, 11, 22, (chtype)'@'); + mvwaddch(treescrn2, 12, 1, (chtype)'@'); + mvwaddch(treescrn2, 12, 23, (chtype)'@'); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + +star() +{ + wstandout(treescrn2); + mvwaddch(treescrn2, 0, 12, (chtype)'*'); + wstandend(treescrn2); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + +strng1() +{ + mvwaddch(treescrn2, 3, 13, (chtype)'\''); + mvwaddch(treescrn2, 3, 12, (chtype)':'); + mvwaddch(treescrn2, 3, 11, (chtype)'.'); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + +strng2() +{ + mvwaddch(treescrn2, 5, 14, (chtype)'\''); + mvwaddch(treescrn2, 5, 13, (chtype)':'); + mvwaddch(treescrn2, 5, 12, (chtype)'.'); + mvwaddch(treescrn2, 5, 11, (chtype)','); + mvwaddch(treescrn2, 6, 10, (chtype)'\''); + mvwaddch(treescrn2, 6, 9, (chtype)':'); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + +strng3() +{ + mvwaddch(treescrn2, 7, 16, (chtype)'\''); + mvwaddch(treescrn2, 7, 15, (chtype)':'); + mvwaddch(treescrn2, 7, 14, (chtype)'.'); + mvwaddch(treescrn2, 7, 13, (chtype)','); + mvwaddch(treescrn2, 8, 12, (chtype)'\''); + mvwaddch(treescrn2, 8, 11, (chtype)':'); + mvwaddch(treescrn2, 8, 10, (chtype)'.'); + mvwaddch(treescrn2, 8, 9, (chtype)','); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + +strng4() +{ + mvwaddch(treescrn2, 9, 17, (chtype)'\''); + mvwaddch(treescrn2, 9, 16, (chtype)':'); + mvwaddch(treescrn2, 9, 15, (chtype)'.'); + mvwaddch(treescrn2, 9, 14, (chtype)','); + mvwaddch(treescrn2, 10, 13, (chtype)'\''); + mvwaddch(treescrn2, 10, 12, (chtype)':'); + mvwaddch(treescrn2, 10, 11, (chtype)'.'); + mvwaddch(treescrn2, 10, 10, (chtype)','); + mvwaddch(treescrn2, 11, 9, (chtype)'\''); + mvwaddch(treescrn2, 11, 8, (chtype)':'); + mvwaddch(treescrn2, 11, 7, (chtype)'.'); + mvwaddch(treescrn2, 11, 6, (chtype)','); + mvwaddch(treescrn2, 12, 5, (chtype)'\''); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + +strng5() +{ + mvwaddch(treescrn2, 11, 19, (chtype)'\''); + mvwaddch(treescrn2, 11, 18, (chtype)':'); + mvwaddch(treescrn2, 11, 17, (chtype)'.'); + mvwaddch(treescrn2, 11, 16, (chtype)','); + mvwaddch(treescrn2, 12, 15, (chtype)'\''); + mvwaddch(treescrn2, 12, 14, (chtype)':'); + mvwaddch(treescrn2, 12, 13, (chtype)'.'); + mvwaddch(treescrn2, 12, 12, (chtype)','); + + /* save a fully lit tree */ + overlay(treescrn2, treescrn); + + wrefresh(treescrn2); + wrefresh(w_del_msg); + return( 0 ); +} + + + +blinkit() +{ + static int cycle; + + if(cycle > 4) + { + cycle = 0; + } + + + touchwin(treescrn8); + + switch(cycle) + { + + case 0: + overlay(treescrn3, treescrn8); + wrefresh(treescrn8); + wrefresh(w_del_msg); + + break; + case 1: + overlay(treescrn4, treescrn8); + wrefresh(treescrn8); + wrefresh(w_del_msg); + + break; + case 2: + overlay(treescrn5, treescrn8); + wrefresh(treescrn8); + wrefresh(w_del_msg); + + break; + case 3: + overlay(treescrn6, treescrn8); + wrefresh(treescrn8); + wrefresh(w_del_msg); + + break; + case 4: + overlay(treescrn7, treescrn8); + wrefresh(treescrn8); + wrefresh(w_del_msg); + + break; + } + + touchwin(treescrn8); + + + + /*ALL ON***************************************************/ + + + overlay(treescrn, treescrn8); + wrefresh(treescrn8); + wrefresh(w_del_msg); + + + ++cycle; + return( 0 ); +} + + +reindeer() +{ + int looper; + + y_pos = 0; + + + for(x_pos = 70; x_pos > 62; x_pos--) + { + if(x_pos < 62) + { + y_pos = 1; + } + for(looper = 0; looper < 4; looper++) + { + mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'.'); + wrefresh(dotdeer0); + wrefresh(w_del_msg); + werase(dotdeer0); + wrefresh(dotdeer0); + wrefresh(w_del_msg); + } + } + + y_pos = 2; + + for(; x_pos > 50; x_pos--) + { + + for(looper = 0; looper < 4; looper++) + { + + if(x_pos < 56) + { + y_pos = 3; + + mvwaddch(stardeer0, y_pos, x_pos, (chtype)'*'); + wrefresh(stardeer0); + wrefresh(w_del_msg); + werase(stardeer0); + wrefresh(stardeer0); + wrefresh(w_del_msg); + } + else + { + mvwaddch(dotdeer0, y_pos, x_pos, (chtype)'*'); + wrefresh(dotdeer0); + wrefresh(w_del_msg); + werase(dotdeer0); + wrefresh(dotdeer0); + wrefresh(w_del_msg); + } + } + } + + x_pos = 58; + + for(y_pos = 2; y_pos < 5; y_pos++) + { + + touchwin(lildeer0); + wrefresh(lildeer0); + wrefresh(w_del_msg); + + for(looper = 0; looper < 4; looper++) + { + mvwin(lildeer3, y_pos, x_pos); + wrefresh(lildeer3); + wrefresh(w_del_msg); + + mvwin(lildeer2, y_pos, x_pos); + wrefresh(lildeer2); + wrefresh(w_del_msg); + + mvwin(lildeer1, y_pos, x_pos); + wrefresh(lildeer1); + wrefresh(w_del_msg); + + mvwin(lildeer2, y_pos, x_pos); + wrefresh(lildeer2); + wrefresh(w_del_msg); + + mvwin(lildeer3, y_pos, x_pos); + wrefresh(lildeer3); + wrefresh(w_del_msg); + + touchwin(lildeer0); + wrefresh(lildeer0); + wrefresh(w_del_msg); + + x_pos -= 2; + } + } + + + x_pos = 35; + + for(y_pos = 5; y_pos < 10; y_pos++) + { + + touchwin(middeer0); + wrefresh(middeer0); + wrefresh(w_del_msg); + + for(looper = 0; looper < 2; looper++) + { + mvwin(middeer3, y_pos, x_pos); + wrefresh(middeer3); + wrefresh(w_del_msg); + + mvwin(middeer2, y_pos, x_pos); + wrefresh(middeer2); + wrefresh(w_del_msg); + + mvwin(middeer1, y_pos, x_pos); + wrefresh(middeer1); + wrefresh(w_del_msg); + + mvwin(middeer2, y_pos, x_pos); + wrefresh(middeer2); + wrefresh(w_del_msg); + + mvwin(middeer3, y_pos, x_pos); + wrefresh(middeer3); + wrefresh(w_del_msg); + + touchwin(middeer0); + wrefresh(middeer0); + wrefresh(w_del_msg); + + x_pos -= 3; + } + } + + usleep(2000); + + y_pos = 1; + + for(x_pos = 8; x_pos < 16; x_pos++) + { + + mvwin(bigdeer4, y_pos, x_pos); + wrefresh(bigdeer4); + wrefresh(w_del_msg); + + mvwin(bigdeer3, y_pos, x_pos); + wrefresh(bigdeer3); + wrefresh(w_del_msg); + + mvwin(bigdeer2, y_pos, x_pos); + wrefresh(bigdeer2); + wrefresh(w_del_msg); + + mvwin(bigdeer1, y_pos, x_pos); + wrefresh(bigdeer1); + wrefresh(w_del_msg); + + mvwin(bigdeer2, y_pos, x_pos); + wrefresh(bigdeer2); + wrefresh(w_del_msg); + + mvwin(bigdeer3, y_pos, x_pos); + wrefresh(bigdeer3); + wrefresh(w_del_msg); + + mvwin(bigdeer4, y_pos, x_pos); + wrefresh(bigdeer4); + wrefresh(w_del_msg); + + mvwin(bigdeer0, y_pos, x_pos); + wrefresh(bigdeer0); + wrefresh(w_del_msg); + } + + --x_pos; + + for(looper = 0; looper < 6; looper++) + { + mvwin(lookdeer4, y_pos, x_pos); + wrefresh(lookdeer4); + wrefresh(w_del_msg); + + mvwin(lookdeer3, y_pos, x_pos); + wrefresh(lookdeer3); + wrefresh(w_del_msg); + + mvwin(lookdeer2, y_pos, x_pos); + wrefresh(lookdeer2); + wrefresh(w_del_msg); + + mvwin(lookdeer1, y_pos, x_pos); + wrefresh(lookdeer1); + wrefresh(w_del_msg); + + mvwin(lookdeer2, y_pos, x_pos); + wrefresh(lookdeer2); + wrefresh(w_del_msg); + + mvwin(lookdeer3, y_pos, x_pos); + wrefresh(lookdeer3); + wrefresh(w_del_msg); + + mvwin(lookdeer4, y_pos, x_pos); + wrefresh(lookdeer4); + wrefresh(w_del_msg); + + } + + mvwin(lookdeer0, y_pos, x_pos); + wrefresh(lookdeer0); + wrefresh(w_del_msg); + + for(; y_pos < 10; y_pos++) + { + + for(looper = 0; looper < 2; looper++) + { + mvwin(bigdeer4, y_pos, x_pos); + wrefresh(bigdeer4); + wrefresh(w_del_msg); + + mvwin(bigdeer3, y_pos, x_pos); + wrefresh(bigdeer3); + wrefresh(w_del_msg); + + mvwin(bigdeer2, y_pos, x_pos); + wrefresh(bigdeer2); + wrefresh(w_del_msg); + + mvwin(bigdeer1, y_pos, x_pos); + wrefresh(bigdeer1); + wrefresh(w_del_msg); + + mvwin(bigdeer2, y_pos, x_pos); + wrefresh(bigdeer2); + wrefresh(w_del_msg); + + mvwin(bigdeer3, y_pos, x_pos); + wrefresh(bigdeer3); + wrefresh(w_del_msg); + + mvwin(bigdeer4, y_pos, x_pos); + wrefresh(bigdeer4); + wrefresh(w_del_msg); + } + mvwin(bigdeer0, y_pos, x_pos); + wrefresh(bigdeer0); + wrefresh(w_del_msg); + } + + --y_pos; + + mvwin(lookdeer3, y_pos, x_pos); + wrefresh(lookdeer3); + wrefresh(w_del_msg); + return( 0 ); +} + + + +void done() +{ + signal(SIGINT,done); + signal(SIGTERM,done); +#if !defined DOS && !defined OS2 + signal(SIGHUP,done); + signal(SIGQUIT,done); +#endif + clear(); + refresh(); + endwin(); + exit(0); +} diff --git a/lib/libncurses/curs_addch.3 b/lib/libncurses/curs_addch.3 new file mode 100644 index 000000000000..2d6e643f0a93 --- /dev/null +++ b/lib/libncurses/curs_addch.3 @@ -0,0 +1,113 @@ +.TH curs_addch 3X "" +.SH NAME +\fBcurs_addch\fR: \fBaddch\fR, \fBwaddch\fR, \fBmvaddch\fR, \fBmvwaddch\fR, +\fBechochar\fR, \fBwechochar\fR - add a character (with attributes) to a +\fBncurses\fR window, then advance the cursor +.SH SYNOPSIS +\fB#include \fR + +\fBaddch(chtype ch);\fR +.br +\fBwaddch(WINDOW *win, chtype ch);\fR +.br +\fBmvaddch(int y, int x, chtype ch);\fR +.br +\fBmvwaddch(WINDOW *win, int y, int x, chtype ch);\fR +.br +\fBechochar(chtype ch);\fR +.br +\fBwechochar(WINDOW *win, chtype ch);\fR +.br +.SH DESCRIPTION +The \fBaddch\fR, \fBwaddch\fR, \fBmvaddch\fR and \fBmvwaddch\fR routines put +the character \fIch\fR into the given window at its current window position, +which is then advanced. They are analogous to \fBputchar\fR in \fBstdio\fR(3). +If the advance is at the right margin, the cursor automatically wraps to the +beginning of the next line. At the bottom of the scrolling region, if +\fBscrollok\fR is enabled, the scrolling region is scrolled up one line. + +If \fIch\fR is a tab, newline, or backspace, the cursor is moved appropriately +within the window. A newline also does a \fBclrtoeol\fR before moving. Tabs +are considered to be at every eighth column. + +If \fIch\fR is any control character other than tab, newline, or backspace, it +is drawn in \fB^\fR\fIX\fR notation. Calling \fBwinch\fR after adding a +control character does not return the control character, but instead returns +the representation of the control character. (To emit control characters +literally, use \fBechochar\fR.) + +Video attributes can be combined with a character by OR-ing them into the +parameter. This results in these attributes also being set. (The intent here +is that text, including attributes, can be copied from one place to another +using \fBinch\fR and \fBaddch\fR.) [see \fBstandout\fR, predefined video +attribute constants, on the curs_attr(3X) page]. + +The \fBechochar\fR and \fBwechochar\fR routines are functionally equivalent to +a call to \fBaddch\fR followed by a call to \fBrefresh\fR, or a call to +\fBwaddch\fR followed by a call to \fBwrefresh\fR. The knowledge that only a +single character is being output is taken into consideration and, for +non-control characters, a considerable performance gain might be seen by using +these routines instead of their equivalents. +.SS Line Graphics +The following variables may be used to add line drawing characters to the +screen with routines of the \fBaddch\fR family. The default character listed +below is used if the \fBacsc\fR capability doesn't define a terminal-specific +replacement for it. The names are taken from the the VT100 nomenclature. + +.TS +l l l +_ _ _ +l l l. +\fIName\fR \fIDefault\fR \fIDescription\fR +ACS_ULCORNER + upper left-hand corner +ACS_LLCORNER + lower left-hand corner +ACS_URCORNER + upper right-hand corner +ACS_LRCORNER + lower right-hand corner +ACS_RTEE + right tee +ACS_LTEE + left tee +ACS_BTEE + bottom tee +ACS_TTEE + top tee +ACS_HLINE - horizontal line +ACS_VLINE | vertical line +ACS_PLUS + plus +ACS_S1 - scan line 1 +ACS_S9 \&_ scan line 9 +ACS_DIAMOND + diamond +ACS_CKBOARD : checker board (stipple) +ACS_DEGREE ' degree symbol +ACS_PLMINUS # plus/minus +ACS_BULLET o bullet +ACS_LARROW < arrow pointing left +ACS_RARROW > arrow pointing right +ACS_DARROW v arrow pointing down +ACS_UARROW ^ arrow pointing up +ACS_BOARD # board of squares +ACS_LANTERN # lantern symbol +ACS_BLOCK # solid square block +.TE + +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion, unless otherwise noted in the +preceding routine descriptions. +.SH BUGS +The ncurses implementation does not yet handle insertion of a character at the +bottom-rightmost position of the screen correctly. If the terminal has the +auto_right_margin property, the real screen will be scrolled up one regardless +of whether scrollok has been enabled for \fBstdscr\fR. + +The entry points \fBechochar\fR and \fBwechochar\fR are not yet implemented in +ncurses 1.8.1. +.SH NOTES +Note that \fBaddch\fR, \fBmvaddch\fR, \fBmvwaddch\fR, and +\fBechochar\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_attr\fR(3X), \fBcurs_clear\fR(3X), +\fBcurs_inch\fR(3X), \fBcurs_outopts\fR(3X), \fBcurs_refresh\fR(3X), +\fBputc\fR(3S). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_addchst.3 b/lib/libncurses/curs_addchst.3 new file mode 100644 index 000000000000..50ed1a320457 --- /dev/null +++ b/lib/libncurses/curs_addchst.3 @@ -0,0 +1,50 @@ +.TH curs_addchstr 3X "" +.SH NAME +\fBcurs_addchstr\fR: \fBaddchstr\fR, \fBaddchnstr\fR, \fBwaddchstr\fR, +\fBwaddchnstr\fR, \fBmvaddchstr\fR, \fBmvaddchnstr\fR, \fBmvwaddchstr\fR, +\fBmvwaddchnstr\fR - add string of characters (and attributes) to a +\fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint addchstr(chtype *chstr);\fR +.br +\fBint addchnstr(chtype *chstr, int n);\fR +.br +\fBint waddchstr(WINDOW *win, chtype *chstr);\fR +.br +\fBint waddchnstr(WINDOW *win, chtype *chstr, int n);\fR +.br +\fBint mvaddchstr(int y, int x, chtype *chstr);\fR +.br +\fBint mvaddchnstr(int y, int x, chtype *chstr, int n);\fR +.br +\fBint mvwaddchstr(WINDOW *win, int y, int x, chtype *chstr);\fR +.br +\fBint mvwaddchnstr(WINDOW *win, int y, int x, chtype *chstr, int n);\fR +.SH DESCRIPTION +These routines copy \fIchstr\fR into the window image structure at and after +the current cursor position. The four routines with \fIn\fR as the last +argument copy at most \fIn\fR elements, but no more than will fit on the line. +If \fBn\fR=\fB-1\fR then the whole string is copied, to the maximum number of +characters that will fit on the line. + +The window cursor is \fINOT\fR advanced, and these routines work faster than +\fBwaddnstr\fR. On the other hand, care must be taken when using them because +they don't perform any kind of checking (such as for the newline character), +they don't advance the current cursor position, and they truncate the string if +it crosses the right margin, rather then wrapping it around to the new line. +.SH RETURN VALUES +All these routines return the integer \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion, unless +otherwise noted in the preceding routine descriptions. +.SH NOTES +Note that all routines except \fBwaddchnstr\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_addstr.3 b/lib/libncurses/curs_addstr.3 new file mode 100644 index 000000000000..ba60b12d2e56 --- /dev/null +++ b/lib/libncurses/curs_addstr.3 @@ -0,0 +1,44 @@ +.TH curs_addstr 3X "" +.SH NAME +\fBcurs_addstr\fR: \fBaddstr\fR, \fBaddnstr\fR, \fBwaddstr\fR, \fBwaddnstr\fR, +\fBmvaddstr\fR, \fBmvaddnstr\fR, \fBmvwaddstr\fR, \fBmvwaddnstr\fR - add a +string of characters to a \fBncurses\fR window and advance cursor +.SH SYNOPSIS +\fB#include \fR + +\fBint addstr(char *str);\fR +.br +\fBint addnstr(char *str, int n);\fR +.br +\fBint waddstr(WINDOW *win, char *str);\fR +.br +\fBint waddnstr(WINDOW *win, char *str, int n);\fR +.br +\fBint mvaddstr(y, int x, char *str);\fR +.br +\fBint mvaddnstr(y, int x, char *str, int n);\fR +.br +\fBint mvwaddstr(WINDOW *win, int y, int x, char *str);\fR +.br +\fBint mvwaddnstr(WINDOW *win, int y, int x, char *str, + int n);\fR +.SH DESCRIPTION +These routines write the characters of the null terminated character string +\fIstr\fR on the given window. It is similar to calling \fBwaddch\fR once for +each character in the string. The four routines with \fIn\fR as the last +argument write at most \fIn\fR characters. If \fIn\fR is negative, then the +entire string will be added. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that all of these routines except \fBwaddstr\fR and \fBwaddnstr\fR may be +macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_addch\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_attr.3 b/lib/libncurses/curs_attr.3 new file mode 100644 index 000000000000..f0f4f5251980 --- /dev/null +++ b/lib/libncurses/curs_attr.3 @@ -0,0 +1,87 @@ +.TH curs_attr 3X "" +.SH NAME +\fBcurs_attr\fR: \fBattroff\fR, \fBwattroff\fR, \fBattron\fR, \fBwattron\fR, +\fBattrset\fR, \fBwattrset\fR, \fBstandend\fR, \fBwstandend\fR, \fBstandout\fR, +\fBwstandout\fR - \fBncurses\fR character and window attribute control routines +.SH SYNOPSIS +\fB#include \fR +.br +\fBint attroff(int attrs);\fR +.br +\fBint wattroff(WINDOW *win, int attrs);\fR +.br +\fBint attron(int attrs);\fR +.br +\fBint wattron(WINDOW *win, int attrs);\fR +.br +\fBint attrset(int attrs);\fR +.br +\fBint wattrset(WINDOW *win, int attrs);\fR +.br +\fBint standend(void);\fR +.br +\fBint wstandend(WINDOW *win);\fR +.br +\fBint standout(void);\fR +.br +\fBint wstandout(WINDOW *win);\fR +.br +.SH DESCRIPTION +These routines manipulate the current attributes of the named window. The +current attributes of a window apply to all characters that are written into +the window with \fBwaddch\fR, \fBwaddstr\fR and \fBwprintw\fR. Attributes are +a property of the character, and move with the character through any scrolling +and insert/delete line/character operations. To the extent possible, they are +displayed as appropriate modifications to the graphic rendition of characters +put on the screen. + +The routine \fBattrset\fR sets the current attributes of the given window to +\fIattrs\fR. The routine \fBattroff\fR turns off the named attributes without +turning any other attributes on or off. The routine \fBattron\fR turns on the +named attributes without affecting any others. The routine \fBstandout\fR is +the same as \fBattron(A_STANDOUT)\fR. The routine \fBstandend\fR is the same +as \fBattrset(A_NORMAL)\fR or \fBattrest(0)\fR, that is, it turns off all +attributes. +.SS Attributes +The following video attributes, defined in \fB\fR, can be passed to +the routines \fBattron\fR, \fBattroff\fR, and \fBattrset\fR, or OR-ed with the +characters passed to \fBaddch\fR. + +.nf +\fBA_NORMAL\fR Normal display (no highlight) +\fBA_STANDOUT\fR Best highlighting mode of the terminal. +\fBA_UNDERLINE\fR Underlining +\fBA_REVERSE\fR Reverse video +\fBA_BLINK\fR Blinking +\fBA_DIM\fR Half bright +\fBA_BOLD\fR Extra bright or bold +\fBA_ALTCHARSET\fR Alternate character set +\fBA_CHARTEXT\fR Bit-mask to extract a character +\fBCOLOR_PAIR(\fR\fIn\fR\fB)\fR Color-pair number \fIn\fR +.fi + +The following macro is the reverse of \fBCOLOR_PAIR(\fR\fIn\fR\fB)\fR: + +.DS C +\fBPAIR_NUMBER(\fIattrs\fR) Returns the pair number associated + with the \fBCOLOR_PAIR(\fR\fIn\fR\fB)\fR attribute. +.DE + +The return values of these routines are not neaningful (many are implemented +as macro-expanded assignments and simply return their argument). The SVr4 +manual page claims (falsely) that these routines always return \fB1\fR. +.SH BUGS +As of 1.8.2, ncurses attributes still have a tendency to stick on in some +circumstances where SVr4 curses attributes would turn off. +.SH NOTES +Note that \fBattroff\fR, \fBwattroff\fR, \fBattron\fR, \fBwattron\fR, +\fBattrset\fR, \fBwattrset\fR, \fBstandend\fR and \fBstandout\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_addch\fR(3X), \fBcurs_addstr\fR(3X), +\fBcurs_printw\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_beep.3 b/lib/libncurses/curs_beep.3 new file mode 100644 index 000000000000..5909c51c889d --- /dev/null +++ b/lib/libncurses/curs_beep.3 @@ -0,0 +1,29 @@ +.TH curs_beep 3X "" +.SH NAME +\fBcurs_beep\fR: \fBbeep\fR, \fBflash\fR - \fBncurses\fR bell and screen flash routines +.SH SYNOPSIS +\fB#include \fR + +\fBint beep(void);\fR +.br +\fBint flash(void);\fR +.br +.SH DESCRIPTION +The \fBbeep\fR and \fBflash\fR routines are used to alert the terminal user. +The routine \fBbeep\fR sounds an audible alarm on the terminal, if possible; +otherwise it flashes the screen (visible bell). The routine \fBflash\fR +flashes the screen, and if that is not possible, sounds the alert. If neither +alert is possible, nothing happens. Nearly all terminals have an audible alert +(bell or beep), but only some can flash the screen. +.SH RETURN VALUE +These routines always return \fBOK\fR. +.SH CAPABILITIES +\fBbell\fR, \fBflash_screen\fR. +.SH SEE ALSO +\fBncurses\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_bkgd.3 b/lib/libncurses/curs_bkgd.3 new file mode 100644 index 000000000000..d2cd2f17268a --- /dev/null +++ b/lib/libncurses/curs_bkgd.3 @@ -0,0 +1,50 @@ +.TH curs_bkgd 3X "" +.SH NAME +\fBcurs_bkgd\fR: \fBbkgdset\fR, \fBwbkgdset\fR, \fBbkgd\fR, +\fBwbkgd\fR - \fBncurses\fR window background manipulation routines +.SH SYNOPSIS +\fB#include \fR + +\fBvoid bkgdset(chtype ch);\fR +.br +\fBvoid wbkgdset(WINDOW *win, chtype ch);\fR +.br +\fBint bkgd(chtype ch);\fR +.br +\fBint wbkgd(WINDOW *win, chtype ch);\fR +.br +.SH DESCRIPTION +The \fBbkgdset\fR and \fBwbkgdset\fR routines manipulate the +background of the named window. Background is a \fBchtype\fR +consisting of any combination of attributes and a character. The +attribute part of the background is combined (ORed) with all non-blank +characters that are written into the window with \fBwaddch\fR. Both +the character and attribute parts of the background are combined with +the blank characters. The background becomes a property of the +character and moves with the character through any scrolling and +insert/delete line/character operations. To the extent possible on a +particular terminal, the attribute part of the background is displayed +as the graphic rendition of the character put on the screen. + +The \fBbkgd\fR and \fBwbkgd\fR routines combine the new background +with every position in the window. Background is any combination of +attributes and a character. Only the attribute part is used to set +the background of non-blank characters, while both character and +attributes are used for blank positions. To the extent possible on a +particular terminal, the attribute part of the background is displayed +as the graphic rendition of the character put on the screen. +.SH RETURN VALUE +\fBbkgd\fR and \fBwbkgd\fR return the integer \fBOK\fR, or a +non-negative integer, if \fBimmedok\fR is set. +.SH NOTES +Note that \fBbkgdset\fR and \fBbkgd\fR may be macros. +.SH BUGS +These features and \fBimmedok\fR are not yet implemented in ncurses 1.8.1. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_addch\fR(3X), \fBcurs_outopts\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_border.3 b/lib/libncurses/curs_border.3 new file mode 100644 index 000000000000..23752bf0f250 --- /dev/null +++ b/lib/libncurses/curs_border.3 @@ -0,0 +1,67 @@ +.TH curs_border 3X "" +.SH NAME +\fBcurs_border\fR: \fBborder\fR, \fBwborder\fR, \fBbox\fR, +\fBhline\fR, \fBwhline\fR, \fBvline\fR, \fBwvline\fR - create +\fBncurses\fR borders, horizontal and vertical lines +.SH SYNOPSIS +\fB#include \fR +.br +\fBint border(chtype ls, chtype rs, chtype ts, chtype bs, + chtype tl, chtype tr, chtype bl, chtype br);\fR +.br +\fBint wborder(WINDOW *win, chtype ls, chtype rs, + chtype ts, chtype bs, chtype tl, chtype tr, + chtype bl, chtype br);\fR +.br +\fBint box(WINDOW *win, chtype verch, chtype horch);\fR +.br +\fBint hline(chtype ch, int n);\fR +.br +\fBint whline(WINDOW *win, chtype ch, int n);\fR +.br +\fBint vline(chtype ch, int n);\fR +.br +\fBint wvline(WINDOW *win, chtype ch, int n);\fR +.br +.SH DESCRIPTION +The \fBborder\fR, \fBwborder\fR and \fBbox\fR routines draw a box around the +edges of a window. The argument \fIls\fR is a character and attributes used +for the left side of the border, \fIrs\fR - right side, \fIts\fR - top side, +\fIbs\fR - bottom side, \fItl\fR - top left-hand corner, \fItr\fR - top +right-hand corner, \fIbl\fR - bottom left-hand corner, and \fIbr\fR - bottom +right-hand corner. If any of these arguments is zero, then the following +default values (defined in \fBncurses.h\fR) are used instead: \fBACS_VLINE, +ACS_VLINE, ACS_HLINE, ACS_HLINE, \fBACS_ULCORNER, ACS_URCORNER, ACS_BLCORNER, +ACS_BRCORNER.\fR + +\fBbox(\fR\fIwin\fR\gB, \fR\fIverch\fR\fB, \fR\fIhorch\fR\fB)\fR is a shorthand +for the following call: \fBwborder(\fR\fIwin\fR\fB,\fR \fIverch\fR\fB,\fR +\fIverch\fR\fB,\fR \fIhorch\fR\fB,\fR \fIhorch\fR\fB, 0, 0, 0, 0)\fR. + +The \fBhline\fR and \fBwhline\fR functions draw a horizontal (left to right) +line using \fIch\fR starting at the current cursor position in the window. The +current cursor position is not changed. The line is at most \fIn\fR characters +long, or as many as fit into the window. + +The \fBvline\fR and \fBwvline\fR functions draw a vertical (top to bottom) line +using \fIch\fR starting at the current cursor position in the window. The +current cursor position is not changed. The line is at most \fIn\fR characters +long, or as many as fit into the window. +.SH RETURN VALUE +All routines return the integer \fBOK\fR. The SVr4.0 manual says "or a +non-negative integer if \fBimmedok\fR is set", but this appears to be an error. +.SH NOTES +The borders generated by these functions are \fIinside\fR borders (this +is also true of SVr4 curses, though the fact is not documented). + +Note that \fBborder\fR and \fBbox\fR may be macros. +.SH BUGS +The \fBimmedok\fR function is not yet implemented in ncurses 1.8.1. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_outopts\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_clear.3 b/lib/libncurses/curs_clear.3 new file mode 100644 index 000000000000..9aeac8df11c0 --- /dev/null +++ b/lib/libncurses/curs_clear.3 @@ -0,0 +1,53 @@ +.TH curs_clear 3X "" +.SH NAME +\fBcurs_clear\fR: \fBerase\fR, \fBwerase\fR, \fBclear\fR, +\fBwclear\fR, \fBclrtobot\fR, \fBwclrtobot\fR, \fBclrtoeol\fR, +\fBwclrtoeol\fR - clear all or part of a \fBncurses\fR window +.SH SYNOPSIS +\fB# include \fR + +\fBint erase(void);\fR +.br +\fBint werase(WINDOW *win);\fR +.br +\fBint clear(void);\fR +.br +\fBint wclear(WINDOW *win);\fR +.br +\fBint clrtobot(void);\fR +.br +\fBint wclrtobot(WINDOW *win);\fR +.br +\fBint clrtoeol(void);\fR +.br +\fBint wclrtoeol(WINDOW *win);\fR +.br +.SH DESCRIPTION +The \fBerase\fR and \fBwerase\fR routines copy blanks to every +position in the window, clearing the screen. + +The \fBclear\fR and \fBwclear\fR routines are like \fBerase\fR and +\fBwerase\fR, but they also call \fBclearok\fR, so that the screen is +cleared completely on the next call to \fBwrefresh\fR for that window +and repainted from scratch. + +The \fBclrtobot\fR and \fBwclrtobot\fR routines erase from the cursor to the +end of screen. That is, they erase all lines below the cursor in the window. +Also, the current line to the right of the cursor, inclusive, is erased. + +The \fBclrtoeol\fR and \fBwclrtoeol\fR routines erase the current line +to the right of the cursor, inclusive. +.SH RETURN VALUE +All routines return the integer \fBOK\fR, or a non-negative integer if +\fBimmedok\fR is set. +.SH NOTES +Note that \fBerase\fR, \fBwerase\fR, \fBclear\fR, \fBwclear\fR, +\fBclrtobot\fR, and \fBclrtoeol\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_outopts\fR(3X), \fBcurs_refresh\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_color.3 b/lib/libncurses/curs_color.3 new file mode 100644 index 000000000000..56f937999c80 --- /dev/null +++ b/lib/libncurses/curs_color.3 @@ -0,0 +1,138 @@ +.TH curs_color 3X "" +.SH NAME +\fBcurs_color\fR: \fBstart_color\fR, \fBinit_pair\fR, +\fBinit_color\fR, \fBhas_colors\fR, \fBcan_change_color\fR, +\fBcolor_content\fR, \fBpair_content\fR - \fBncurses\fR color +manipulation routines +.SH SYNOPSIS +\fB# include \fR +.br +\fBint start_color(void);\fR +.br +\fBint init_pair(short pair, short f, short b);\fR +.br +\fBint init_color(short color, short r, short g, short b);\fR +.br +\fBbool has_colors(void);\fR +.br +\fBbool can_change_color(void);\fR +.br +\fBint color_content(short color, short *r, short *g, short *b);\fR +.br +\fBint pair_content(short pair, short *f, short *b);\fR +.br +.SH DESCRIPTION +.SS Overview +\fBncurses\fR support color attributes on terminals with that capability. To +use these routines \fBstart_color\fR must be called, usually right after +\fBinitscr\fR. Colors are always used in pairs (referred to as color-pairs). +A color-pair consists of a foreground color (for characters) and a background +color (for the blank field on which the characters are displayed). A +programmer initializes a color-pair with the routine \fBinit_pair\fR. After it +has been initialized, \fBCOLOR_PAIR\fR(\fIn\fR), a macro defined in +\fB\fR, can be used as a new video attribute. + +If a terminal is capable of redefining colors, the programmer can use the +routine \fBinit_color\fR to change the definition of a color. The routines +\fBhas_colors\fR and \fBcan_change_color\fR return \fBTRUE\fR or \fBFALSE\fR, +depending on whether the terminal has color capabilities and whether the +programmer can change the colors. The routine \fBcolor_content\fR allows a +programmer to extract the amounts of red, green, and blue components in an +initialized color. The routine \fBpair_content\fR allows a programmer to find +out how a given color-pair is currently defined. +.SS Routine Descriptions +The \fBstart_color\fR routine requires no arguments. It must be +called if the programmer wants to use colors, and before any other +color manipulation routine is called. It is good practice to call +this routine right after \fBinitscr\fR. \fBstart_color\fR initializes +eight basic colors (black, red, green, yellow, blue, magenta, cyan, +and white), and two global variables, \fBCOLORS\fR and +\fBCOLOR_PAIRS\fR (respectively defining the maximum number of colors +and color-pairs the terminal can support). It also restores the +colors on the terminal to the values they had when the terminal was +just turned on. + +The \fBinit_pair\fR routine changes the definition of a color-pair. It takes +three arguments: the number of the color-pair to be changed, the foreground +color number, and the background color number. The value of the first argument +must be between \fB1\fR and \fBCOLOR_PAIRS-1\fR. The value of the second and +third arguments must be between 0 and \fBCOLORS\fR (the 0 color pair is wired +to white on black and cannot be changed). If the color-pair was previously +initialized, the screen is refreshed and all occurrences of that color-pair is +changed to the new definition. + +The \fBinit_color\fR routine changes the definition of a color. It takes four +arguments: the number of the color to be changed followed by three RGB values +(for the amounts of red, green, and blue components). The value of the first +argument must be between \fB0\fR and \fBCOLORS\fR. (See the section +\fBColors\fR for the default color index.) Each of the last three arguments +must be a value between 0 and 1000. When \fBinit_color\fR is used, all +occurrences of that color on the screen immediately change to the new +definition. + +The \fBhas_colors\fR routine requires no arguments. It returns \fBTRUE\fR if +the terminal can manipulate colors; otherwise, it returns \fBFALSE\fR. This +routine facilitates writing terminal-independent programs. For example, a +programmer can use it to decide whether to use color or some other video +attribute. + +The \fBcan_change_color\fR routine requires no arguments. It returns +\fBTRUE\fR if the terminal supports colors and can change their definitions; +other, it returns \fBFALSE\fR. This routine facilitates writing +terminal-independent programs. + +The \fBcolor_content\fR routine gives programmers a way to find the intensity +of the red, green, and blue (RGB) components in a color. It requires four +arguments: the color number, and three addresses of \fBshort\fRs for storing +the information about the amounts of red, green, and blue components in the +given color. The value of the first argument must be between 0 and +\fBCOLORS\fR. The values that are stored at the addresses pointed to by the +last three arguments are between 0 (no component) and 1000 (maximum amount of +component). + +The \fBpair_content\fR routine allows programmers to find out what colors a +given color-pair consists of. It requires three arguments: the color-pair +number, and two addresses of \fBshort\fRs for storing the foreground and the +background color numbers. The value of the first argument must be between 1 +and \fBCOLOR_PAIRS-1\fR. The values that are stored at the addresses pointed +to by the second and third arguments are between 0 and \fBCOLORS\fR. +.SS Colors +In \fB\fR the following macros are defined. These are the default +colors. \fBncurses\fR also assumes that \fBCOLOR_BLACK\fR is the default +background color for all terminals. + +.nf + \fBCOLOR_BLACK\fR + \fBCOLOR_RED\fR + \fBCOLOR_GREEN\fR + \fBCOLOR_YELLOW\fR + \fBCOLOR_BLUE\fR + \fBCOLOR_MAGENTA\fR + \fBCOLOR_CYAN\fR + \fBCOLOR_WHITE\fR +.fi +.SH RETURN VALUE +All routines that return an integer return \fBERR\fR upon failure and \fBOK\fR +upon successful completion. +.SH BUGS +Several caveats apply onn 386 and 486 machines with VGA-compatible graphics: + +COLOR_YELLOW is actually brown. To get yellow, use COLOR_YELLOW combined with +the \fBA_BOLD\fR attribute. + +The A_BLINK attribute should in theory cause the background to go bright. This +often fails to work, and even some cards for which it mostly works (such as the +Paradise and compatibles) do the wrong thing when you try to set a bright +"yellow" background (you get a blinking yellow foreground instead). + +Color RGB values are not settable. +.SH CAPABILITIES +\fBsetf\fR, \fBsetb\fR, \fBsetaf\fR, \fBsetab\fR. The ncurses library uses +the second pair by preference, falling back to the first. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_initscr\fR(3X), \fBcurs_attr\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 diff --git a/lib/libncurses/curs_delch.3 b/lib/libncurses/curs_delch.3 new file mode 100644 index 000000000000..02514458d359 --- /dev/null +++ b/lib/libncurses/curs_delch.3 @@ -0,0 +1,34 @@ +.TH curs_delch 3X "" +.SH NAME +\fBcurs_delch\fR: \fBdelch\fR, \fBwdelch\fR, \fBmvdelch\fR, \fBmvwdelch\fR - +delete character under the cursor in a \fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint delch(void);\fR +.br +\fBint wdelch(WINDOW *win);\fR +.br +\fBint mvdelch(int y, int x);\fR +.br +\fBint mvwdelch(WINDOW *win, int y, int x);\fR +.br +.SH DESCRIPTION +These routines delete the character under the cursor; all characters to the +right of the cursor on the same line are moved to the left one position and the +last character on the line is filled with a blank. The cursor position does +not change (after moving to \fIy\fR, \fIx\fR, if specified). (This does not +imply use of the hardware delete character feature.) +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that \fBdelch\fR, \fBmvdelch\fR, and \fBmvwdelch\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_delln.3 b/lib/libncurses/curs_delln.3 new file mode 100644 index 000000000000..d8a3c4674aba --- /dev/null +++ b/lib/libncurses/curs_delln.3 @@ -0,0 +1,53 @@ +.TH curs_deleteln 3X "" +.SH NAME +\fBcurs_deleteln\fR: \fBdeleteln\fR, \fBwdeleteln\fR, \fBinsdelln\fR, +\fBwinsdelln\fR, \fBinsertln\fR, \fBwinsertln\fR - delete and insert +lines in a \fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint deleteln(void);\fR +.br +\fBint wdeleteln(WINDOW *win);\fR +.br +\fBint insdelln(int n);\fR +.br +\fBint winsdelln(WINDOW *win, int n);\fR +.br +\fBint insertln(void);\fR +.br +\fBint winsertln(WINDOW *win);\fR +.br +.SH DESCRIPTION +The \fBdeleteln\fR and \fBwdeleteln\fR routines delete the line under the +cursor in the window; all lines below the current line are moved up one line. +The bottom line of the window is cleared. The cursor position does not change. + +The \fBinsdelln\fR and \fBwinsdelln\fR routines, for positive \fIn\fR, insert +\fIn\fR lines into the specified window above the current line. The \fIn\fR +bottom lines are lost. For negative \fIn\fR, delete \fIn\fR lines (starting +with the one under the cursor), and move the remaining lines up. The bottom +\fIn\fR lines are cleared. The current cursor position remains the same. + +The \fBinsertln\fR and \fBinsertln\fR routines, insert a blank line above the +current line and the bottom line is lost. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion. +.SH BUGS +All the above should be implemented through \fBwinsdelln\fR() but +currently only \fBinsdelln\fR() is implemented in terms of it. +.SH NOTES +Note that all but \fBwinsdelln\fR may be a macros. + +These routines do not require a hardware line delete or insert feature in the +terminal. In fact, they won't use hardware line delete/insert unless +\fBidlok(..., TRUE)\fR has been set on the current window. +.SH SEE ALSO +\fBncurses\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_getch.3 b/lib/libncurses/curs_getch.3 new file mode 100644 index 000000000000..1b16502a47ca --- /dev/null +++ b/lib/libncurses/curs_getch.3 @@ -0,0 +1,188 @@ +.TH curs_getch 3X "" +.SH NAME +\fBcurs_getch\fR: \fBgetch\fR, \fBwgetch\fR, \fBmvgetch\fR, +\fBmvwgetch\fR, \fBungetch\fR - get (or push back) characters from +\fBncurses\fR terminal keyboard +.SH SYNOPSIS +\fB#include \fR + +\fBint getch(void);\fR +.br +\fBint wgetch(WINDOW *win);\fR +.br +\fBint mvgetch(int y, int x);\fR +.br +\fBint mvwgetch(WINDOW *win, int y, int x);\fR +.br +\fBint ungetch(int ch);\fR +.br +.SH DESCRIPTION +The \fBgetch\fR, \fBwgetch\fR, \fBmvgetch\fR and \fBmvwgetch\fR, routines read +a character from the window. In no-delay mode, if no input is waiting, the +value \fBERR\fR is returned. In delay mode, the program waits until the system +passes text through to the program. Depending on the setting of \fBcbreak\fR, +this is after one character (cbreak mode), or after the first newline (nocbreak +mode). In half-delay mode, the program waits until a character is typed or the +specified timeout has been reached. Unless \fBnoecho\fR has been set, the +character will also be echoed into the designated window. + +If the window is not a pad, and it has been moved or modified since the last +call to \fBwrefresh\fR, \fBwrefresh\fR will be called before another character +is read. + +If \fBkeypad\fR is \fBTRUE\fR, and a function key is pressed, the token for +that function key is returned instead of the raw characters. Possible function +keys are defined in \fB\fR as macros with values outside the range +of 8-bit characters whose names begin with \fBKEY_.\fR Thus, a variable +intended to hold the return value of a function key must be of short size or +larger. + +When a character that could be the beginning of a function key is received +(which, on modern terminals, means an escape character), \fBncurses\fR sets a +timer. If the remainder of the sequence does not come in within the designated +time, the character is passed through; otherwise, the function key value is +returned. For this reason, many terminals experience a delay between the time +a user presses the escape key and the escape is returned to the program. + +The \fBungetch\fR routine places \fIch\fR back onto the input queue to be +returned by the next call to \fBwgetch\fR. Note that there is, in effect, +just one input queue for all windows. + +.SS Function Keys +The following function keys, defined in \fB\fR, might be returned by +\fBgetch\fR if \fBkeypad\fR has been enabled. Note that not all of these are +necessarily supported on any particular terminal. +.nf +__________________________________________________________________ +\fIName\fR \fIKey\fR \fIname\fR +__________________________________________________________________ +KEY_BREAK Break key +KEY_DOWN The four arrow keys ... +KEY_UP +KEY_LEFT +KEY_RIGHT +KEY_HOME Home key (upward+left arrow) +KEY_BACKSPACE Backspace +KEY_F0 Function keys; space for 64 keys is reserved. +KEY_F(\fIn\fR) For 0 \fI<\fR \fIn\fR \fI<\fR 63 +KEY_DL Delete line +KEY_IL Insert line +KEY_DC Delete character +KEY_IC Insert char or enter insert mode +KEY_EIC Exit insert char mode +KEY_CLEAR Clear screen +KEY_EOS Clear to end of screen +KEY_EOL Clear to end of line +KEY_SF Scroll 1 line forward +KEY_SR Scroll 1 line backward (reverse) +KEY_NPAGE Next page +KEY_PPAGE Previous page +KEY_STAB Set tab +KEY_CTAB Clear tab +KEY_CATAB Clear all tabs +KEY_ENTER Enter or send +KEY_SRESET Soft (partial) reset +KEY_RESET Reset or hard reset +KEY_PRINT Print or copy +KEY_LL Home down or bottom (lower left). Keypad is + arranged like this: + \fBA1\fR \fBup\fR \fBA3\fR + \fBleft\fR \fBB2\fR \fBright\fR + \fBC1\fR \fBdown\fR \fBC3\fR +KEY_A1 Upper left of keypad +KEY_A3 Upper right of keypad +KEY_B2 Center of keypad +KEY_C1 Lower left of keypad +KEY_C3 Lower right of keypad +KEY_BTAB Back tab key +KEY_BEG Beg(inning) key +KEY_CANCEL Cancel key +KEY_CLOSE Close key +KEY_COMMAND Cmd (command) key +KEY_COPY Copy key +KEY_CREATE Create key +KEY_END End key +KEY_EXIT Exit key +KEY_FIND Find key +KEY_HELP Help key +KEY_MARK Mark key +KEY_MESSAGE Message key +KEY_MOVE Move key +KEY_NEXT Next object key +KEY_OPEN Open key +KEY_OPTIONS Options key +KEY_PREVIOUS Previous object key +KEY_REDO Redo key +KEY_REFERENCE Ref(erence) key +KEY_REFRESH Refresh key +KEY_REPLACE Replace key +KEY_RESTART Restart key +KEY_RESUME Resume key +KEY_SAVE Save key +KEY_SBEG Shifted beginning key +KEY_SCANCEL Shifted cancel key +KEY_SCOMMAND Shifted command key +KEY_SCOPY Shifted copy key +KEY_SCREATE Shifted create key +KEY_SDC Shifted delete char key +KEY_SDL Shifted delete line key +KEY_SELECT Select key +KEY_SEND Shifted end key +KEY_SEOL Shifted clear line key +KEY_SEXIT Shifted exit key +KEY_SFIND Shifted find key +KEY_SHELP Shifted help key +KEY_SHOME Shifted home key +KEY_SIC Shifted input key +KEY_SLEFT Shifted left arrow key +KEY_SMESSAGE Shifted message key +KEY_SMOVE Shifted move key +KEY_SNEXT Shifted next key +KEY_SOPTIONS Shifted options key +KEY_SPREVIOUS Shifted prev key +KEY_SPRINT Shifted print key +KEY_SREDO Shifted redo key +KEY_SREPLACE Shifted replace key +KEY_SRIGHT Shifted right arrow +KEY_SRSUME Shifted resume key +KEY_SSAVE Shifted save key +KEY_SSUSPEND Shifted suspend key +KEY_SUNDO Shifted undo key +KEY_SUSPEND Suspend key +KEY_UNDO Undo key +.fi + +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion. +.SH NOTES +Use of the escape key by a programmer for a single character function is +discouraged, as it will cause a delay of up to one second while the +keypad code looks for a following function-key sequence. + +When using \fBgetch\fR, \fBwgetch\fR, \fBmvgetch\fR, or +\fBmvwgetch\fR, nocbreak mode (\fBnocbreak\fR) and echo mode +(\fBecho\fR) should not be used at the same time. Depending on the +state of the tty driver when each character is typed, the program may +produce undesirable results. + +Note that \fBgetch\fR, \fBmvgetch\fR, and \fBmvwgetch\fR may be macros. + +Historically, the set of keypad macros was largely defined by the extremely +function-key-rich keyboard of the AT&T 7300, aka 3B1, aka Safari 4. Modern +personal computers usually have only a small subset of these. IBM PC-style +consoles typically support little more than \fBKEY_UP\fR, \fBKEY_DOWN\fR, +\fBKEY_LEFT\fR, \fBKEY_RIGHT\fR, \fBKEY_HOME\fR, \fBKEY_END\fR, +\fBKEY_NPAGE\fR, \fBKEY_PPAGE\fR, and function keys 1 through 12. The Ins key +is usually mapped to \fBKEY_IC\fR. +.SH CAPABILITIES +All of the key_* capabilities; also \fBkeypad_local\fR and \fBkeypad_xmit\fR. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_inopts\fR(3X), \fBcurs_move\fR(3X), +\fBcurs_refresh\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_getstr.3 b/lib/libncurses/curs_getstr.3 new file mode 100644 index 000000000000..1151ae0c1a51 --- /dev/null +++ b/lib/libncurses/curs_getstr.3 @@ -0,0 +1,53 @@ +.TH curs_getstr 3X "" +.SH NAME +\fBcurs_getstr\fR: \fBgetstr\fR, \fBwgetstr\fR, \fBmvgetstr\fR, +\fBmvwgetstr\fR, \fBwgetnstr\fR - accept character strings from +\fBncurses\fR terminal keyboard +.SH SYNOPSIS +\fB#include \fR + +\fBint getstr(char *str);\fR +.br +\fBint wgetstr(WINDOW *win, char *str);\fR +.br +\fBint mvgetstr(int y, int x, char *str);\fR +.br +\fBint mvwgetstr(WINDOW *win, int y, int x, char *str);\fR +.br +\fBint wgetnstr(WINDOW *win, char *str, int n);\fR +.br +.SH DESCRIPTION +The function \fBgetstr\fR is equivalent to a series of calls to \fBgetch\fR, +until a newline or carriage return is received (the terminating character is +not included in the returned string). The resulting value is placed in the +area pointed to by the character pointer \fIstr\fR. + +\fBwgetnstr\fR reads at most \fIn\fR characters, thus preventing a possible +overflow of the input buffer. Any attempt to enter more characters (other +than the terminating newline or carriage return) causes a beep. + +The user's erase and kill characters are interpreted. If keypad +mode is on for the window, \fBKEY_LEFT\fR and \fBKEY_BACKSPACE\fR +are both considered equivalent to the user's kill character. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH BUGS +When the window is in keypad mode and the user types any special key +other than those named above, the `character' value appended to the +string by the ncurses implementation is predictable but not useful +(being, in fact, the low-order eight bits of the key's KEY_ value). + +The SVr4.0 documentation claims that "special keys (such as function +keys, "home" key, "clear" key, \fIetc\fR.) are interpreted" without +giving details. It lies. The actual behavior is like that of ncurses. +.SH NOTES +Note that \fBgetstr\fR, \fBmvgetstr\fR, and \fBmvwgetstr\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_getch\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_getyx.3 b/lib/libncurses/curs_getyx.3 new file mode 100644 index 000000000000..42fb0067be26 --- /dev/null +++ b/lib/libncurses/curs_getyx.3 @@ -0,0 +1,41 @@ +.TH curs_getyx 3X "" +.SH NAME +\fBcurs_getyx\fR: \fBgetyx\fR, \fBgetparyx\fR, \fBgetbegyx\fR, +\fBgetmaxyx\fR - get \fBncurses\fR cursor and window coordinates +.SH SYNOPSIS +\fB#include \fR + +\fBvoid getyx(WINDOW *win, int y, int x);\fR +.br +\fBvoid getparyx(WINDOW *win, int y, int x);\fR +.br +\fBvoid getbegyx(WINDOW *win, int y, int x);\fR +.br +\fBvoid getmaxyx(WINDOW *win, int y, int x);\fR +.br +.SH DESCRIPTION +The \fBgetyx\fR macro places the cursor position of the window in the two +integer variables \fIy\fR and \fIx\fR. + +If \fIwin\fR is a subwindow, the \fBgetparyx\fR macro places the beginning +coordinates of the subwindow relative to the parent window into two integer +variables \fIy\fR and \fIx\fR. Otherwise, \fB-1\fR is placed into \fIy\fR and +\fIx\fR. + +Like \fBgetyx\fR, the \fBgetbegyx\fR and \fBgetmaxyx\fR macros store +the current beginning coordinates and size of the specified window. +.SH RETURN VALUE +The return values of these macros are undefined (\fIi\fR.\fIe\fR., +they should not be used as the right-hand side of assignment +statements). +.SH NOTES +All of these interfaces are macros and that "\fB&\fR" is not +necessary before the variables \fIy\fR and \fIx\fR. +.SH SEE ALSO +\fBncurses\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_inch.3 b/lib/libncurses/curs_inch.3 new file mode 100644 index 000000000000..202673988094 --- /dev/null +++ b/lib/libncurses/curs_inch.3 @@ -0,0 +1,40 @@ +.TH curs_inch 3X "" +.SH NAME +\fBcurs_inch\fR: \fBinch\fR, \fBwinch\fR, \fBmvinch\fR, \fBmvwinch\fR +- get a character and attributes from a \fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBchtype inch(void);\fR +.br +\fBchtype winch(WINDOW *win);\fR +.br +\fBchtype mvinch(int y, int x);\fR +.br +\fBchtype mvwinch(WINDOW *win, int y, int x);\fR +.br +.SH DESCRIPTION +These routines return the character, of type \fBchtype\fR, at the current +position in the named window. If any attributes are set for that position, +their values are OR-ed into the value returned. Constants defined in +\fB\fR can be used with the \fB&\fR (logical AND) operator to +extract the character or attributes alone. + +.SS Attributes +The following bit-masks may be AND-ed with characters returned by \fBwinch\fR. + +.nf +\fBA_CHARTEXT\fR Bit-mask to extract character +\fBA_ATTRIBUTES\fR Bit-mask to extract attributes +\fBA_COLOR\fR Bit-mask to extract color-pair field information +.fi +.SH NOTES +Note that all of these routines may be macros. +.SH SEE ALSO +\fBncurses\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_inchstr.3 b/lib/libncurses/curs_inchstr.3 new file mode 100644 index 000000000000..0ee8c1f60cac --- /dev/null +++ b/lib/libncurses/curs_inchstr.3 @@ -0,0 +1,46 @@ +.TH curs_inchstr 3X "" +.SH NAME +\fBcurs_inchstr\fR: \fBinchstr\fR, \fBinchnstr\fR, \fBwinchstr\fR, +\fBwinchnstr\fR, \fBmvinchstr\fR, \fBmvinchnstr\fR, \fBmvwinchstr\fR, +\fBmvwinchnstr\fR - get a string of characters (and attributes) from a +\fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint inchstr(chtype *chstr);\fR +.br +\fBint inchnstr(chtype *chstr, int n);\fR +.br +\fBint winchstr(WINDOW *win, chtype *chstr);\fR +.br +\fBint winchnstr(WINDOW *win, chtype *chstr, int n);\fR +.br +\fBint mvinchstr(int y, int x, chtype *chstr);\fR +.br +\fBint mvinchnstr(int y, int x, chtype *chstr, int n);\fR +.br +\fBint mvwinchstr(WINDOW *win, int y, int x, chtype *chstr);\fR +.br +\fBint mvwinchnstr(WINDOW *win, int y, int x, chtype *chstr, int n);\fR +.br +.SH DESCRIPTION +These routines return a NULL-terminated array of \fBchtype\fR quantities, +starting at the current cursor position in the named window and ending at the +right margin of the window. The four functions with \fIn\fR as +the last argument, return a leading substring at most \fIn\fR characters long. +Constants defined in \fB\fR can be used with the \fB&\fR (logical +AND) operator to extract the character or the attribute alone from any position +in the \fIchstr\fR [see curs_inch(3X)]. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that all routines except \fBwinchnstr\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_inch\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_initscr.3 b/lib/libncurses/curs_initscr.3 new file mode 100644 index 000000000000..9badf748fba5 --- /dev/null +++ b/lib/libncurses/curs_initscr.3 @@ -0,0 +1,84 @@ +.TH curs_initscr 3X "" +.SH NAME +\fBcurs_initscr\fR: \fBinitscr\fR, \fBnewterm\fR, \fBendwin\fR, +\fBisendwin\fR, \fBset_term\fR, \fBdelscreen\fR - \fBncurses\fR screen +initialization and manipulation routines +.SH SYNOPSIS +\fB#include \fR + +\fBWINDOW *initscr(void);\fR +.br +\fBint endwin(void);\fR +.br +\fBint isendwin(void);\fR +.br +\fBSCREEN *newterm(char *type, FILE *outfd, FILE *infd);\fR +.br +\fBSCREEN *set_term(SCREEN *new);\fR +.br +\fBvoid delscreen(SCREEN* sp);\fR +.br +.SH DESCRIPTION +\fBinitscr\fR is normally the first \fBncurses\fR routine to call when +initializing a program. A few special routines sometimes need to be +called before it; these are \fBslk_init\fR, \fBfilter\fR, \fBripoffline\fR, +\fBuse_env\fR. For multiple-terminal applications, or in order to test +for the presence of given capabilities, \fBnewterm\fR may be called before +\fBinitscr\fR. + +The initscr code determines the terminal type and initializes all \fBncurses\fR +data structures. \fBinitscr\fR also causes the first call to \fBrefresh\fR to +clear the screen. If errors occur, \fBinitscr\fR writes an appropriate error +message to standard error and exits; otherwise, a pointer is returned to +\fBstdscr\fR. + +A program that outputs to more than one terminal should use the \fBnewterm\fR +routine for each terminal instead of \fBinitscr\fR. A program that needs to +inspect capabilities, so it can continue to run in a line-oriented mode if the +terminal cannot support a screen-oriented program, would also use +\fBnewterm\fR. The routine \fBnewterm\fR should be called once for each +terminal. It returns a variable of type \fBSCREEN *\fR which should be saved +as a reference to that terminal. The arguments are the \fItype\fR of the +terminal to be used in place of \fB$TERM\fR, a file pointer for output to the +terminal, and another file pointer for input from the terminal (if \fItype\fR +is \fBNULL\fR, \fB$TERM\fR will be used). The program must also call +\fBendwin\fR for each terminal being used before exiting from ncurses. If +\fBnewterm\fR is called more than once for the same terminal, the first +terminal referred to must be the last one for which \fBendwin\fR is called. + +A program should always call \fBendwin\fR before exiting or escaping from +\fBncurses\fR mode temporarily. This routine restores tty modes, moves the +cursor to the lower left-hand corner of the screen and resets the terminal into +the proper non-visual mode. Calling \fBrefresh\fR or \fBdoupdate\fR after a +temporary escape causes the program to resume visual mode. + +The \fBisendwin\fR routine returns \fBTRUE\fR if \fBendwin\fR has been +called without any subsequent calls to \fBwrefresh\fR, and \fBFALSE\fR +otherwise. + +The \fBset_term\fR routine is used to switch between different +terminals. The screen reference \fBnew\fR becomes the new current +terminal. The previous terminal is returned by the routine. This is +the only routine which manipulates \fBSCREEN\fR pointers; all other +routines affect only the current terminal. + +The \fBdelscreen\fR routine frees storage associated with the +\fBSCREEN\fR data structure. The \fBendwin\fR routine does not do +this, so \fBdelscreen\fR should be called after \fBendwin\fR if a +particular \fBSCREEN\fR is no longer needed. +.SH RETURN VALUE +\fBendwin\fR returns the integer \fBERR\fR upon failure and \fBOK\fR +upon successful completion. + +Routines that return pointers always return \fBNULL\fR on error. +.SH NOTES +Note that \fBinitscr\fR and \fBnewterm\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_kernel\fR(3X), \fBcurs_refresh\fR(3X), +\fBcurs_slk\fR(3X), \fBcurs_util\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_inopts.3 b/lib/libncurses/curs_inopts.3 new file mode 100644 index 000000000000..c2372100262e --- /dev/null +++ b/lib/libncurses/curs_inopts.3 @@ -0,0 +1,170 @@ +.TH curs_inopts 3X "" +.SH NAME +\fBcurs_inopts\fR: \fBcbreak\fR, \fBnocbreak\fR, \fBecho\fR, +\fBnoecho\fR, \fBhalfdelay\fR, \fBintrflush\fR, \fBkeypad\fR, +\fBmeta\fR, \fBnodelay\fR, \fBnotimeout\fR, \fBraw\fR, \fBnoraw\fR, +\fBnoqiflush\fR, \fBqiflush\fR, \fBtimeout\fR, \fBwtimeout\fR, +\fBtypeahead\fR - \fBncurses\fR input options +.SH SYNOPSIS +\fB#include \fR + +\fBint cbreak(void);\fR +.br +\fBint nocbreak(void);\fR +.br +\fBint echo(void);\fR +.br +\fBint noecho(void);\fR +.br +\fBint halfdelay(int tenths);\fR +.br +\fBint intrflush(WINDOW *win, bool bf);\fR +.br +\fBint keypad(WINDOW *win, bool bf);\fR +.br +\fBint meta(WINDOW *win, bool bf);\fR +.br +\fBint nodelay(WINDOW *win, bool bf);\fR +.br +\fBint notimeout(WINDOW *win, bool bf);\fR +.br +\fBint raw(void);\fR +.br +\fBint noraw(void);\fR +.br +\fBvoid noqiflush(void);\fR +.br +\fBvoid qiflush(void);\fR +.br +\fBvoid timeout(int delay);\fR +.br +\fBvoid wtimeout(WINDOW *win, int delay);\fR +.br +\fBint typeahead(int fd);\fR +.br +.SH DESCRIPTION +Normally, the tty driver buffers typed characters until a newline or carriage +return is typed. The \fBcbreak\fR routine disables line buffering and +erase/kill character-processing (interrupt and flow control characters are +unaffected), making characters typed by the user immediately available to the +program. The \fBnocbreak\fR routine returns the terminal to normal (cooked) +mode. + +Initially the terminal may or may not be in \fBcbreak\fR mode, as the mode is +inherited; therefore, a program should call \fBcbreak\fR or \fBnocbreak\fR +explicitly. Most interactive programs using \fBncurses\fR set the \fBcbreak\fR +mode. Note that \fBcbreak\fR overrides \fBraw\fR. [See curs_getch(3X) for a +discussion of how these routines interact with \fBecho\fR and \fBnoecho\fR.] + +The \fBecho\fR and \fBnoecho\fR routines control whether characters typed by +the user are echoed by \fBgetch\fR as they are typed. Echoing by the tty +driver is always disabled, but initially \fBgetch\fR is in echo mode, so +characters typed are echoed. Authors of most interactive programs prefer to do +their own echoing in a controlled area of the screen, or not to echo at all, so +they disable echoing by calling \fBnoecho\fR. [See curs_getch(3X) for a +discussion of how these routines interact with \fBcbreak\fR and +\fBnocbreak\fR.] + +The \fBhalfdelay\fR routine is used for half-delay mode, which is similar to +\fBcbreak\fR mode in that characters typed by the user are immediately +available to the program. However, after blocking for \fItenths\fR tenths of +seconds, ERR is returned if nothing has been typed. The value of \fBtenths\fR +must be a number between 1 and 255. Use \fBnocbreak\fR to leave half-delay +mode. + +If the \fBintrflush\fR option is enabled, (\fIbf\fR is \fBTRUE\fR), when an +interrupt key is pressed on the keyboard (interrupt, break, quit) all output in +the tty driver queue will be flushed, giving the effect of faster response to +the interrupt, but causing \fBncurses\fR to have the wrong idea of what is on +the screen. Disabling (\fIbf\fR is \fBFALSE\fR), the option prevents the +flush. The default for the option is inherited from the tty driver settings. +The window argument is ignored. + +The \fBkeypad\fR option enables the keypad of the user's terminal. If +enabled (\fIbf\fR is \fBTRUE\fR), the user can press a function key +(such as an arrow key) and \fBwgetch\fR returns a single value +representing the function key, as in \fBKEY_LEFT\fR. If disabled +(\fIbf\fR is \fBFALSE\fR), \fBncurses\fR does not treat function keys +specially and the program has to interpret the escape sequences +itself. If the keypad in the terminal can be turned on (made to +transmit) and off (made to work locally), turning on this option +causes the terminal keypad to be turned on when \fBwgetch\fR is +called. The default value for keypad is false. + +Initially, whether the terminal returns 7 or 8 significant bits on +input depends on the control mode of the tty driver [see termio(7)]. +To force 8 bits to be returned, invoke \fBmeta\fR(\fIwin\fR, +\fBTRUE\fR). To force 7 bits to be returned, invoke +\fBmeta\fR(\fIwin\fR, \fBFALSE\fR). The window argument, \fIwin\fR, +is always ignored. If the terminfo capabilities \fBsmm\fR (meta_on) +and \fBrmm\fR (meta_off) are defined for the terminal, \fBsmm\fR is +sent to the terminal when \fBmeta\fR(\fIwin\fR, \fBTRUE\fR) is called +and \fBrmm\fR is sent when \fBmeta\fR(\fIwin\fR, \fBFALSE\fR) is +called. + +The \fBnodelay\fR option causes \fBgetch\fR to be a non-blocking call. +If no input is ready, \fBgetch\fR returns \fBERR\fR. If disabled +(\fIbf\fR is \fBFALSE\fR), \fBgetch\fR waits until a key is pressed. + +While interpreting an input escape sequence, \fBwgetch\fR sets a timer +while waiting for the next character. If \fBnotimeout(\fR\fIwin\fR, +\fBTRUE\fR) is called, then \fBwgetch\fR does not set a timer. The +purpose of the timeout is to differentiate between sequences received +from a function key and those typed by a user. + +With the \fBraw\fR and \fBnoraw\fR routines, the terminal is placed +into or out of raw mode. Raw mode is similar to \fBcbreak\fR mode, in +that characters typed are immediately passed through to the user +program. The differences are that in raw mode, the interrupt, quit, +suspend, and flow control characters are all passed through +uninterpreted, instead of generating a signal. The behavior of the +BREAK key depends on other bits in the tty driver that are not set by +\fBncurses\fR. + +When the \fBnoqiflush\fR routine is used, normal flush of input and +output queues associated with the \fBINTR\fR, \fBQUIT\fR and +\fBSUSP\fR characters will not be done [see termio(7)]. When +\fBqiflush\fR is called, the queues will be flushed when these control +characters are read. + +The \fBtimeout\fR and \fBwtimeout\fR routines set blocking or +non-blocking read for a given window. If \fIdelay\fR is negative, +blocking read is used (\fIi\fR.\fIe\fR., waits indefinitely for +input). If \fIdelay\fR is zero, then non-blocking read is used +(\fIi\fR.\fIe\fR., read returns \fBERR\fR if no input is waiting). If +\fIdelay\fR is positive, then read blocks for \fIdelay\fR +milliseconds, and returns \fBERR\fR if there is still no input. +Hence, these routines provide the same functionality as \fBnodelay\fR, +plus the additional capability of being able to block for only +\fIdelay\fR milliseconds (where \fIdelay\fR is positive). + +\fBncurses\fR does ``line-breakout optimization'' by looking for +typeahead periodically while updating the screen. If input is found, +and it is coming from a tty, the current update is postponed until +\fBrefresh\fR or \fBdoupdate\fR is called again. This allows faster +response to commands typed in advance. Normally, the input FILE +pointer passed to \fBnewterm\fR, or \fBstdin\fR in the case that +\fBinitscr\fR was used, will be used to do this typeahead checking. +The \fBtypeahead\fR routine specifies that the file descriptor +\fIfd\fR is to be used to check for typeahead instead. If \fIfd\fR is +-1, then no typeahead checking is done. +.SH RETURN VALUE +All routines that return an integer return \fBERR\fR upon failure and an +integer value other than \fBERR\fR upon successful completion, unless otherwise +noted in the preceding routine descriptions. +.SH NOTES +Note that \fBecho\fR, \fBnoecho\fR, \fBhalfdelay\fR, \fBintrflush\fR, +\fBmeta\fR, \fBnodelay\fR, \fBnotimeout\fR, \fBnoqiflush\fR, +\fBqiflush\fR, \fBtimeout\fR, and \fBwtimeout\fR may be macros. +.SH BUGS +The entry points \fBintrflush\fR, \fBqiflush\fR, \fBnoqiflush\fR, and +\fBtypeahead\fR are not yet implemented in ncurses 1.8.1. The ncurses +code does not do typeahead checking during input as SVr4 curses does. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_getch\fR(3X), \fBcurs_initscr\fR(3X), \fBtermio\fR(7) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_insch.3 b/lib/libncurses/curs_insch.3 new file mode 100644 index 000000000000..a332230b19eb --- /dev/null +++ b/lib/libncurses/curs_insch.3 @@ -0,0 +1,36 @@ +.TH curs_insch 3X "" +.SH NAME +\fBcurs_insch\fR: \fBinsch\fR, \fBwinsch\fR, \fBmvinsch\fR, \fBmvwinsch\fR - +insert a character before cursor in a \fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint insch(chtype ch);\fR +.br +\fBint winsch(WINDOW *win, chtype ch);\fR +.br +\fBint mvinsch(int y, int x, chtype ch);\fR +.br +\fBint mvwinsch(WINDOW *win, int y, int x, chtype ch);\fR +.br +.SH DESCRIPTION +These routines, insert the character \fIch\fR before the character under the +cursor. All characters to the right of the cursor are moved one space to the +right, with the possibility of the rightmost character on the line being lost. +The insertion operation does not change the cursor position. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +These routines do not necessarily imply use of a hardware insert character +feature. + +Note that \fBinsch\fR, \fBmvinsch\fR, and \fBmvwinsch\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_insstr.3 b/lib/libncurses/curs_insstr.3 new file mode 100644 index 000000000000..85cad112202d --- /dev/null +++ b/lib/libncurses/curs_insstr.3 @@ -0,0 +1,57 @@ +.TH curs_insstr 3X "" +.SH NAME +\fBcurs_instr\fR: \fBinsstr\fR, \fBinsnstr\fR, \fBwinsstr\fR, \fBwinsnstr\fR, +\fBmvinsstr\fR, \fBmvinsnstr\fR, \fBmvwinsstr\fR, \fBmvwinsnstr\fR - insert +string before cursor a \fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR +.br +\fBint insstr(char *str);\fR +.br +\fBint insnstr(char *str, int n);\fR +.br +\fBint winsstr(WINDOW *win, char *str);\fR +.br +\fBint winsnstr(WINDOW *win, char *str, int n);\fR +.br +\fBint mvinsstr(int y, int x, char *str);\fR +.br +\fBint mvinsnstr(int y, int x, char *str, int n);\fR +.br +\fBint mvwinsstr(WINDOW *win, int y, int x, char *str);\fR +.br +\fBint mvwinsnstr(WINDOW *win, int y, int x, char *str, int n);\fR +.br +.SH DESCRIPTION +These routines insert a character string (as many characters as will fit on the +line) before the character under the cursor. All characters to the right of +the cursor are shifted right, with the possibility of the rightmost characters +on the line being lost. The cursor position does not change (after moving to +\fIy\fR, \fIx\fR, if specified). The four routines with \fIn\fR as the last +argument insert a leading substring of at most \fIn\fR characters. If +\fIn\fR<=0, then the entire string is inserted. + +If a character in \fIstr\fR is a tab, newline, carriage return or +backspace, the cursor is moved appropriately within the window. A +newline also does a \fBclrtoeol\fR before moving. Tabs are considered +to be at every eighth column. If a character in \fIstr\fR is another +control character, it is drawn in the \fB^\fR\fIX\fR notation. +Calling \fBwinch\fR after adding a control character (and moving to +it, if necessary) does not return the control character, but instead +returns a character in the the ^-representation of the control character. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH BUGS +Entry points for these functions are n ncurses.h but they are not +implemented as of ncurses 1.8.5. +.SH NOTES +Note that all but \fBwinsnstr\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_clear\fR(3X), \fBcurs_inch\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_instr.3 b/lib/libncurses/curs_instr.3 new file mode 100644 index 000000000000..f109afea7746 --- /dev/null +++ b/lib/libncurses/curs_instr.3 @@ -0,0 +1,44 @@ +.TH curs_instr 3X "" +.SH NAME +\fBcurs_instr\fR: \fBinstr\fR, \fBinnstr\fR, \fBwinstr\fR, \fBwinnstr\fR, +\fBmvinstr\fR, \fBmvinnstr\fR, \fBmvwinstr\fR, \fBmvwinnstr\fR - get a string +of characters from a \fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint instr(char *str);\fR +.br +\fBint innstr(char *str, int n);\fR +.br +\fBint winstr(WINDOW *win, char *str);\fR +.br +\fBint winnstr(WINDOW *win, char *str, int n);\fR +.br +\fBint mvinstr(int y, int x, char *str);\fR +.br +\fBint mvinnstr(int y, int x, char *str, int n);\fR +.br +\fBint mvwinstr(WINDOW *win, int y, int x, char *str);\fR +.br +\fBint mvwinnstr(WINDOW *win, int y, int x, char *str, int n);\fR +.br +.SH DESCRIPTION +These routines return a string of characters in \fIstr\fR, extracted starting +at the current cursor position in the named window and ending at the right +margin of the window. Attributes are stripped from the characters. The four +functions with \fIn\fR as the last argument return a leading substring at most +\fIn\fR characters long. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that all routines except \fBwinnstr\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: + diff --git a/lib/libncurses/curs_kernel.3 b/lib/libncurses/curs_kernel.3 new file mode 100644 index 000000000000..24084f6fad94 --- /dev/null +++ b/lib/libncurses/curs_kernel.3 @@ -0,0 +1,113 @@ +.TH curs_kernel 3X "" +.SH NAME +\fBcurs_kernel\fR: \fBdef_prog_mode\fR, \fBdef_shell_mode\fR, +\fBreset_prog_mode\fR, \fBreset_shell_mode\fR, \fBresetty\fR, +\fBsavetty\fR, \fBgetsyx\fR, \fBsetsyx\fR, \fBripoffline\fR, +\fBcurs_set\fR, \fBnapms\fR - low-level \fBncurses\fR routines +.SH SYNOPSIS +\fB#include \fR + +\fBint def_prog_mode(void);\fR +.br +\fBint def_shell_mode(void);\fR +.br +\fBint reset_prog_mode(void);\fR +.br +\fBint reset_shell_mode(void);\fR +.br +\fBint resetty(void);\fR +.br +\fBint savetty(void);\fR +.br +\fBint getsyx(int y, int x);\fR +.br +\fBint setsyx(int y, int x);\fR +.br +\fBint ripoffline(int line, int (*init)(WINDOW *, int));\fR +.br +\fBint curs_set(int visibility);\fR +.br +\fBint napms(int ms);\fR +.br +.SH DESCRIPTION +The following routines give low-level access to various \fBncurses\fR +capabilities. Theses routines typically are used inside library +routines. + +The \fBdef_prog_mode\fR and \fBdef_shell_mode\fR routines save the +current terminal modes as the "program" (in \fBncurses\fR) or "shell" +(not in \fBncurses\fR) state for use by the \fBreset_prog_mode\fR and +\fBreset_shell_mode\fR routines. This is done automatically by +\fBinitscr\fR. + +The \fBreset_prog_mode\fR and \fBreset_shell_mode\fR routines restore +the terminal to "program" (in \fBncurses\fR) or "shell" (out of +\fBncurses\fR) state. These are done automatically by \fBendwin\fR +and, after an \fBendwin\fR, by \fBdoupdate\fR, so they normally are +not called. + +The \fBresetty\fR and \fBsavetty\fR routines save and restore the +state of the terminal modes. \fBsavetty\fR saves the current state in +a buffer and \fBresetty\fR restores the state to what it was at the +last call to \fBsavetty\fR. + +With the \fBgetsyx\fR routine, the current coordinates of the virtual +screen cursor are returned in \fIy\fR and \fIx\fR. If \fBleaveok\fR +is currently \fBTRUE\fR, then \fB-1\fR,\fB-1\fR is returned. If lines +have been removed from the top of the screen, using \fBripoffline\fR, +\fIy\fR and \fIx\fR include these lines; therefore, \fIy\fR and +\fIx\fR should be used only as arguments for \fBsetsyx\fR. + +With the \fBsetsyx\fR routine, the virtual screen cursor is set to +\fIy\fR, \fIx\fR. If \fIy\fR and \fIx\fR are both \fB-1\fR, then +\fBleaveok\fR is set. The two routines \fBgetsyx\fR and \fBsetsyx\fR +are designed to be used by a library routine, which manipulates +\fBncurses\fR windows but does not want to change the current position +of the program's cursor. The library routine would call \fBgetsyx\fR +at the beginning, do its manipulation of its own windows, do a +\fBwnoutrefresh\fR on its windows, call \fBsetsyx\fR, and then call +\fBdoupdate\fR. + +The \fBripoffline\fR routine provides access to the same facility that +\fBslk_init\fR [see curs_slk(3X)] uses to reduce the size of the +screen. \fBripoffline\fR must be called before \fBinitscr\fR or +\fBnewterm\fR is called. If \fIline\fR is positive, a line is removed +from the top of \fBstdscr\fR; if \fIline\fR is negative, a line is +removed from the bottom. When this is done inside \fBinitscr\fR, the +routine \fBinit\fR (supplied by the user) is called with two +arguments: a window pointer to the one-line window that has been +allocated and an integer with the number of columns in the window. +Inside this initialization routine, the integer variables \fBLINES\fR +and \fBCOLS\fR (defined in \fB\fR) are not guaranteed to be +accurate and \fBwrefresh\fR or \fBdoupdate\fR must not be called. It +is allowable to call \fBwnoutrefresh\fR during the initialization +routine. + +\fBripoffline\fR can be called up to five times before calling \fBinitscr\fR or +\fBnewterm\fR. + +The \fBcurs_set\fR routine sets the cursor state is set to invisible, +normal, or very visible for \fBvisibility\fR equal to \fB0\fR, +\fB1\fR, or \fB2\fR respectively. If the terminal supports the +\fIvisibility\fR requested, the previous \fIcursor\fR state is +returned; otherwise, \fBERR\fR is returned. + +The \fBnapms\fR routine is used to sleep for \fIms\fR milliseconds. +.SH RETURN VALUE +Except for \fBcurs_set\fR, these routines always return \fBOK\fR. +\fBcurs_set\fR returns the previous cursor state, or \fBERR\fR if the +requested \fIvisibility\fR is not supported. +.SH NOTES +Note that \fBgetsyx\fR is a macro, so \fB&\fR is not necessary before +the variables \fIy\fR and \fIx\fR. +.SH BUGS +The return value of curs_set is currently incorrect. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_initscr\fR(3X), \fBcurs_outopts\fR(3X), \fBcurs_refresh\fR(3X), +\fBcurs_scr_dump\fR(3X), \fBcurs_slk\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_move.3 b/lib/libncurses/curs_move.3 new file mode 100644 index 000000000000..f7bdfd322f57 --- /dev/null +++ b/lib/libncurses/curs_move.3 @@ -0,0 +1,28 @@ +.TH curs_move 3X "" +.SH NAME +\fBcurs_move\fR: \fBmove\fR, \fBwmove\fR - move \fBncurses\fR window cursor +.SH SYNOPSIS +\fB#include \fR + +\fBint move(int y, int x);\fR +.br +\fBint wmove(WINDOW *win, int y, int x);\fR +.br +.SH DESCRIPTION +These routines move the cursor associated with the window to line \fIy\fR and +column \fIx\fR. This routine does not move the physical cursor of the terminal +until \fBrefresh\fR is called. The position specified is relative to the upper +left-hand corner of the window, which is (0,0). +.SH RETURN VALUE +These routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that \fBmove\fR may be a macro. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_refresh\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_outopts.3 b/lib/libncurses/curs_outopts.3 new file mode 100644 index 000000000000..ccf800d8c630 --- /dev/null +++ b/lib/libncurses/curs_outopts.3 @@ -0,0 +1,114 @@ +.TH curs_outopts 3X "" +.SH NAME +\fBcurs_outopts\fR: \fBclearok\fR, \fBidlok\fR, \fBidcok immedok\fR, +\fBleaveok\fR, \fBsetscrreg\fR, \fBwsetscrreg\fR, \fBscrollok\fR, +\fBnl\fR, \fBnonl\fR - \fBncurses\fR output options +.SH SYNOPSIS +\fB#include \fR + +\fBint clearok(WINDOW *win, bool bf);\fR +.br +\fBint idlok(WINDOW *win, bool bf);\fR +.br +\fBvoid idcok(WINDOW *win, bool bf);\fR +.br +\fBvoid immedok(WINDOW *win, bool bf);\fR +.br +\fBint leaveok(WINDOW *win, bool bf);\fR +.br +\fBint setscrreg(int top, int bot);\fR +.br +\fBint wsetscrreg(WINDOW *win, int top, int bot);\fR +.br +\fBint scrollok(WINDOW *win, bool bf);\fR +.br +\fBint nl(void);\fR +.br +\fBint nonl(void);\fR +.br +.SH DESCRIPTION +These routines set options that change the style of output within +\fBncurses\fR. All options are initially \fBFALSE\fR, unless otherwise stated. +It is not necessary to turn these options off before calling \fBendwin\fR. + +With the \fBclearok\fR routine, if enabled (\fIbf\fR is \fBTRUE\fR), the next +call to \fBwrefresh\fR with this window will clear the screen completely and +redraw the entire screen from scratch. This is useful when the contents of the +screen are uncertain, or in some cases for a more pleasing visual effect. If +the \fIwin\fR argument to \fBclearok\fR is the global variable \fBcurscr\fR, +the next call to \fBwrefresh\fR with any window causes the screen to be cleared +and repainted from scratch. + +With the \fBidlok\fR routine, if enabled (\fIbf\fR is \fBTRUE\fR), +\fBncurses\fR considers using the hardware insert/delete line feature of +terminals so equipped. If disabled (\fIbf\fR is \fBFALSE\fR), \fBncurses\fR +very seldom uses this feature. (The insert/delete character feature is always +considered.) This option should be enabled only if the application needs +insert/delete line, for example, for a screen editor. It is disabled by +default because insert/delete line tends to be visually annoying when used in +applications where it isn't really needed. If insert/delete line cannot be +used, \fBncurses\fR redraws the changed portions of all lines. + +With the \fBidcok\fR routine, if enabled (\fIbf\fR is \fBTRUE\fR), +\fBncurses\fR considers using the hardware insert/delete character feature of +terminals so equipped. This is enabled by default. + +With the \fBimmedok\fR routine, if enabled (\fIbf\fR is \fBTRUE)\fR, any change +in the window image, such as the ones caused by \fBwaddch, wclrtobot, wscrl\fR, +\fIetc\fR., automatically cause a call to \fBwrefresh\fR. However, it may +degrade the performance considerably, due to repeated calls to \fBwrefresh\fR. +It is disabled by default. + +Normally, the hardware cursor is left at the location of the window cursor +being refreshed. The \fBleaveok\fR option allows the cursor to be left +wherever the update happens to leave it. It is useful for applications where +the cursor is not used, since it reduces the need for cursor motions. If +possible, the cursor is made invisible when this option is enabled. + +The \fBsetscrreg\fR and \fBwsetscrreg\fR routines allow the application +programmer to set a software scrolling region in a window. \fItop\fR and +\fIbot\fR are the line numbers of the top and bottom margin of the scrolling +region. (Line 0 is the top line of the window.) If this option and +\fBscrollok\fR are enabled, an attempt to move off the bottom margin line +causes all lines in the scrolling region to scroll up one line. Only the text +of the window is scrolled. (Note that this has nothing to do with the use of a +physical scrolling region capability in the terminal, like that in the VT100. +If \fBidlok\fR is enabled and the terminal has either a scrolling region or +insert/delete line capability, they will probably be used by the output +routines.) + +The \fBscrollok\fR option controls what happens when the cursor of a window is +moved off the edge of the window or scrolling region, either as a result of a +newline action on the bottom line, or typing the last character of the last +line. If disabled, (\fIbf\fR is \fBFALSE\fR), the cursor is left on the bottom +line. If enabled, (\fIbf\fR is \fBTRUE\fR), \fBwrefresh\fR is called on the +window, and the physical terminal and window are scrolled up one line. [Note +that in order to get the physical scrolling effect on the terminal, it is also +necessary to call \fBidlok\fR.] + +The \fBnl\fR and \fBnonl\fR routines control whether newline is translated into +carriage return and linefeed on output, and whether return is translated into +newline on input. Initially, the translations do occur. By disabling these +translations using \fBnonl\fR, \fBncurses\fR is able to make better use of the +linefeed capability, resulting in faster cursor motion. +.SH RETURN VALUE +\fBsetscrreg\fR and \fBwsetscrreg\fR return \fBOK\fR upon success and \fBERR\fR upon failure. +All other routines that return an integer always return \fBOK\fR. +.SH BUGS +The entry points \fBidcok\fR, \fBimmedok\fR are not yet implemented in +ncurses 1.8.1. +.SH NOTES +Note that \fBclearok\fR, \fBleaveok\fR, \fBscrollok\fR, \fBidcok\fR, \fBnl\fR, +\fBnonl\fR and \fBsetscrreg\fR may be macros. + +The \fBimmedok\fR routine is useful for windows that are used as terminal +emulators. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_addch\fR(3X), \fBcurs_clear\fR(3X), +\fBcurs_initscr\fR(3X), \fBcurs_scroll\fR(3X), \fBcurs_refresh\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_overlay.3 b/lib/libncurses/curs_overlay.3 new file mode 100644 index 000000000000..bc9723a37c77 --- /dev/null +++ b/lib/libncurses/curs_overlay.3 @@ -0,0 +1,41 @@ +.TH curs_overlay 3X "" +.SH NAME +\fBcurs_overlay\fR: \fBoverlay\fR, \fBoverwrite\fR, \fBcopywin\fR - overlay and +manipulate overlapped \fBncurses\fR windows +.SH SYNOPSIS +\fB#include \fR + +\fBint overlay(WINDOW *srcwin, WINDOW *dstwin);\fR +.br +\fBint overwrite(WINDOW *srcwin, WINDOW *dstwin);\fR +.br +\fBint copywin(WINDOW *srcwin, WINDOW *dstwin, int sminrow, + int smincol, int dminrow, int dmincol, int dmaxrow, + int dmaxcol, int overlay);\fR +.SH DESCRIPTION +The \fBoverlay\fR and \fBoverwrite\fR routines overlay \fIsrcwin\fR on +top of \fIdstwin\fR. \fIscrwin\fR and \fIdstwin\fR are not required +to be the same size; only text where the two windows overlap is +copied. The difference is that \fBoverlay\fR is non-destructive +(blanks are not copied) whereas \fBoverwrite\fR is destructive. + +The \fBcopywin\fR routine provides a finer granularity of control over the +\fBoverlay\fR and \fBoverwrite\fR routines. Like in the \fBprefresh\fR +routine, a rectangle is specified in the destination window, (\fIdminrow\fR, +\fIdmincol\fR) and (\fIdmaxrow\fR, \fIdmaxcol\fR), and the upper-left-corner +coordinates of the source window, (\fIsminrow\fR, \fIsmincol\fR). If the +argument \fIoverlay\fR is \fBtrue\fR, then copying is non-destructive, as in +\fBoverlay\fR. +.SH RETURN VALUE +Routines that return an integer return \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion. +.SH NOTES +Note that \fBoverlay\fR and \fBoverwrite\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_pad\fR(3X), \fBcurs_refresh\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_pad.3 b/lib/libncurses/curs_pad.3 new file mode 100644 index 000000000000..726630f71ff6 --- /dev/null +++ b/lib/libncurses/curs_pad.3 @@ -0,0 +1,75 @@ +.TH curs_pad 3X "" +.SH NAME +\fBcurs_pad\fR: \fBnewpad\fR, \fBsubpad\fR, \fBprefresh\fR, +\fBpnoutrefresh\fR, \fBpechochar\fR - create and display \fBncurses\fR +pads +.SH SYNOPSIS +\fB#include \fR + +\fBWINDOW *newpad(int nlines, int ncols);\fR +.br +\fBWINDOW *subpad(WINDOW *orig, int nlines, int ncols, + int begin_y, int begin_x);\fR +\fBint prefresh(WINDOW *pad, int pminrow, int pmincol, + int sminrow, int smincol, int smaxrow, int smaxcol);\fR +\fBint pnoutrefresh(WINDOW *pad, int pminrow, int pmincol, + int sminrow, int smincol, int smaxrow, int smaxcol);\fR +\fBint pechochar(WINDOW *pad, chtype ch);\fR +.SH DESCRIPTION +The \fBnewpad\fR routine creates and returns a pointer to a new pad data +structure with the given number of lines, \fInlines\fR, and columns, +\fIncols\fR. A pad is like a window, except that it is not restricted by the +screen size, and is not necessarily associated with a particular part of the +screen. Pads can be used when a large window is needed, and only a part of the +window will be on the screen at one time. Automatic refreshes of pads +(\fIe\fR.\fIg\fR., from scrolling or echoing of input) do not occur. It is not +legal to call \fBwrefresh\fR with a \fIpad\fR as an argument; the routines +\fBprefresh\fR or \fBpnoutrefresh\fR should be called instead. Note that these +routines require additional parameters to specify the part of the pad to be +displayed and the location on the screen to be used for the display. + +The \fBsubpad\fR routine creates and returns a pointer to a subwindow within a +pad with the given number of lines, \fInlines\fR, and columns, \fIncols\fR. +Unlike \fBsubwin\fR, which uses screen coordinates, the window is at position +(\fIbegin\fR_\fIx\fR\fB,\fR \fIbegin\fR_\fIy\fR) on the pad. The window is +made in the middle of the window \fIorig\fR, so that changes made to one window +affect both windows. During the use of this routine, it will often be +necessary to call \fBtouchwin\fR or \fBtouchline\fR on \fIorig\fR before +calling \fBprefresh\fR. + +The \fBprefresh\fR and \fBpnoutrefresh\fR routines are analogous to +\fBwrefresh\fR and \fBwnoutrefresh\fR except that they relate to pads instead +of windows. The additional parameters are needed to indicate what part of the +pad and screen are involved. \fIpminrow\fR and \fIpmincol\fR specify the upper +left-hand corner of the rectangle to be displayed in the pad. \fIsminrow\fR, +\fIsmincol\fR, \fIsmaxrow\fR, and \fIsmaxcol\fR specify the edges of the +rectangle to be displayed on the screen. The lower right-hand corner of the +rectangle to be displayed in the pad is calculated from the screen coordinates, +since the rectangles must be the same size. Both rectangles must be entirely +contained within their respective structures. Negative values of +\fIpminrow\fR, \fIpmincol\fR, \fIsminrow\fR, or \fIsmincol\fR are treated as if +they were zero. + +The \fBpechochar\fR routine is functionally equivalent to a call to \fBaddch\fR +followed by a call to \fBrefresh\fR, a call to \fBwaddch\fR followed by a call +to \fBwrefresh\fR, or a call to \fBwaddch\fR followed by a call to +\fBprefresh.\fR The knowledge that only a single character is being output is +taken into consideration and, for non-control characters, a considerable +performance gain might be seen by using these routines instead of their +equivalents. In the case of \fBpechochar\fR, the last location of the pad on +the screen is reused for the arguments to \fBprefresh\fR. +.SH RETURN VALUE +Routines that return an integer return \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion. + +Routines that return pointers return \fBNULL\fR on error. +.SH NOTES +Note that \fBpechochar\fR may be a macro. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_refresh\fR(3X), \fBcurs_touch\fR(3X), \fBcurs_addch\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_printw.3 b/lib/libncurses/curs_printw.3 new file mode 100644 index 000000000000..b58dba41057a --- /dev/null +++ b/lib/libncurses/curs_printw.3 @@ -0,0 +1,42 @@ +.TH curs_printw 3X "" +.SH NAME +\fBcurs_printw\fR: \fBprintw\fR, \fBwprintw\fR, \fBmvprintw\fR, +\fBmvwprintw\fR, \fBvwprintw\fR - print formatted output in +\fBncurses\fR windows +.SH SYNOPSIS +\fB#include \fR + +\fBint printw(char *fmt\fR [\fB, arg\fR] \fB...);\fR +.br +\fBint wprintw(WINDOW *win, char *fmt\fR [\fB, arg\fR] \fB...);\fR +.br +\fBint mvprintw(int y, int x, char *fmt\fR [\fB, arg\fR] \fB...);\fR +.br +\fBint mvwprintw(WINDOW *win, int y, int x, + \fBchar *fmt\fR [\fB, arg]\fR ...); + +\fB#include \fR +.br +\fBint vwprintw(WINDOW *win, char *fmt, varglist);\fR +.br +.SH DESCRIPTION +The \fBprintw\fR, \fBwprintw\fR, \fBmvprintw\fR and \fBmvwprintw\fR +routines are analogous to \fBprintf\fR [see \fBprintf\fR(3S)]. In +effect, the string that would be output by \fBprintf\fR is output +instead as though \fBwaddstr\fR were used on the given window. + +The \fBvwprintw\fR routine is analogous to \fBvprintf\fR [see +\fBprintf\fR(3S)] and performs a \fBwprintw\fR using a variable +argument list. The third argument is a \fBva_list\fR, a pointer to a +list of arguments, as defined in \fB\fR. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH SEE ALSO +\fBncurses\fR(3X), \fBprintf\fR(3S), \fBvprintf(3S)\fR +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_refresh.3 b/lib/libncurses/curs_refresh.3 new file mode 100644 index 000000000000..3445d757df04 --- /dev/null +++ b/lib/libncurses/curs_refresh.3 @@ -0,0 +1,69 @@ +.TH curs_refresh 3X "" +.SH NAME +\fBcurs_refresh\fR: \fBrefresh\fR, \fBwrefresh\fR, \fBwnoutrefresh\fR, +\fBdoupdate\fR, \fBredrawwin\fR, \fBwredrawln\fR - refresh +\fBncurses\fR windows and lines +.SH SYNOPSIS +\fB#include \fR + +\fBint refresh(void);\fR +.br +\fBint wrefresh(WINDOW *win);\fR +.br +\fBint wnoutrefresh(WINDOW *win);\fR +.br +\fBint doupdate(void);\fR +.br +\fBint redrawwin(WINDOW *win);\fR +.br +\fBint wredrawln(WINDOW *win, int beg_line, int num_lines);\fR +.br +.SH DESCRIPTION +The \fBrefresh\fR and \fBwrefresh\fR routines (or \fBwnoutrefresh\fR and +\fBdoupdate\fR) must be called to get actual output to the terminal, as other +routines merely manipulate data structures. The routine \fBwrefresh\fR copies +the named window to the physical terminal screen, taking into account what is +already there in order to do optimizations. The \fBrefresh\fR routine is the +same, using \fBstdscr\fR as the default window. Unless \fBleaveok\fR has been +enabled, the physical cursor of the terminal is left at the location of the +cursor for that window. + +The \fBwnoutrefresh\fR and \fBdoupdate\fR routines allow multiple updates with +more efficiency than \fBwrefresh\fR alone. In addition to all the window +structures, \fBncurses\fR keeps two data structures representing the terminal +screen: a physical screen, describing what is actually on the screen, and a +virtual screen, describing what the programmer wants to have on the screen. + +The routine \fBwrefresh\fR works by first calling \fBwnoutrefresh\fR, which +copies the named window to the virtual screen, and then calling \fBdoupdate\fR, +which compares the virtual screen to the physical screen and does the actual +update. If the programmer wishes to output several windows at once, a series +of calls to \fBwrefresh\fR results in alternating calls to \fBwnoutrefresh\fR +and \fBdoupdate\fR, causing several bursts of output to the screen. By first +calling \fBwnoutrefresh\fR for each window, it is then possible to call +\fBdoupdate\fR once, resulting in only one burst of output, with fewer total +characters transmitted and less CPU time used. If the \fIwin\fR argument to +\fBwrefresh\fR is the global variable \fBcurscr\fR, the screen is immediately +cleared and repainted from scratch. + +The \fBredrawwin\fR routine indicates to \fBncurses\fR that some screen lines +are corrupted and should be thrown away before anything is written over them. +These routines could be used for programs such as editors, which want a command +to redraw some part of the screen or the entire screen. The routine +\fBredrawln\fR is preferred over \fBredrawwin\fR where a noisy communication +line exists and redrawing the entire window could be subject to even more +communication noise. Just redrawing several lines offers the possibility that +they would show up unblemished. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that \fBrefresh\fR and \fBredrawwin\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_outopts\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_scanw.3 b/lib/libncurses/curs_scanw.3 new file mode 100644 index 000000000000..15efca39df5e --- /dev/null +++ b/lib/libncurses/curs_scanw.3 @@ -0,0 +1,44 @@ +.TH curs_scanw 3X "" +.SH NAME +\fBcurs_scanw\fR: \fBscanw\fR, \fBwscanw\fR, \fBmvscanw\fR, +\fBmvwscanw\fR, \fBvwscanw\fR - convert formatted input from a +\fBncurses\fR widow +.SH SYNOPSIS +\fB#include \fR + +\fBint scanw(char *fmt\fR [\fB, arg\fR] \fB...);\fR +.br +\fBint wscanw(WINDOW *win, char *fmt\fR [\fB, arg\fR] \fB...);\fR +.br +\fBint mvscanw(int y, int x, char *fmt\fR [\fB, arg\fR] \fB...);\fR +.br +\fBint mvwscanw(WINDOW *win, int y, int x, + char *fmt\fR [\fB, arg]\fR \fB...);\fR +.br +\fBint vwscanw(WINDOW *win, char *fmt, va_list varglist);\fR +.SH DESCRIPTION +The \fBscanw\fR, \fBwscanw\fR and \fBmvscanw\fR routines are analogous to +\fBscanf\fR [see \fBscanf\fR(3S)]. The effect of these routines is as though +\fBwgetstr\fR were called on the window, and the resulting line used as input +for \fBsscanf\fR(3). Fields which do not map to a variable in the \fIfmt\fR +field are lost. + +The \fBvwscanw\fR routine is similar to \fBvwprintw\fR in that it performs a +\fBwscanw\fR using a variable argument list. The third argument is a +\fIva\fR_\fIlist\fR, a pointer to a list of arguments, as defined in +\fB\fR. +.SH RETURN VALUE +\fBvwscanw\fR returns \fBERR\fR on failure and an integer equal to the +number of fields scanned on success. + +Applications may use the return value from the \fBscanw\fR, \fBwscanw\fR, +\fBmvscanw\fR and \fBmvwscanw\fR routines to determine the number of fields +which were mapped in the call. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_getstr\fR, \fBcurs_printw\fR, \fBscanf\fR(3S) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_scr_dmp.3 b/lib/libncurses/curs_scr_dmp.3 new file mode 100644 index 000000000000..2572f98590f1 --- /dev/null +++ b/lib/libncurses/curs_scr_dmp.3 @@ -0,0 +1,56 @@ +.TH curs_scr_dump 3X "" +.SH NAME +\fBcurs_scr_dump\fR: \fBscr_dump\fR, \fBscr_restore\fR, +\fBscr_init\fR, \fBscr_set\fR - read (write) a \fBncurses\fR screen +from (to) a file +.SH SYNOPSIS +\fB#include \fR + +\fBint scr_dump(char *filename);\fR +.br +\fBint scr_restore(char *filename);\fR +.br +\fBint scr_init(char *filename);\fR +.br +\fBint scr_set(char *filename);\fR +.br +.SH DESCRIPTION +The \fBscr_dump\fR routine dumps the current contents of the virtual screen +to the file \fIfilename\fR. + +With the \fBscr_restore\fR routine, the virtual screen is set to the contents +of \fIfilename\fR, which must have been written using \fBscr_dump\fR. The next +call to \fBdoupdate\fR restores the screen to the way it looked in the dump +file. + +With the \fBscr_init\fR routine, the contents of \fIfilename\fR are read in and +used to initialize the \fBncurses\fR data structures about what the terminal +currently has on its screen. If the data is determined to be valid, +\fBncurses\fR bases its next update of the screen on this information rather +than clearing the screen and starting from scratch. \fBscr_init\fR is used +after \fBinitscr\fR or a \fBsystem\fR [see \fBsystem\fR(BA_LIB)] call to share +the screen with another process which has done a \fBscr_dump\fR after its +\fBendwin\fR call. The data is declared invalid if the time-stamp of the tty +is old or the terminfo capabilities \fBrmcup\fR and \fBnrrmc\fR exist. + +The \fBscr_set\fR routine is a combination of \fBscr_restore\fR and +\fBscr_init\fR. It tells the program that the information in \fIfilename\fR is +what is currently on the screen, and also what the program wants on the screen. +This can be thought of as a screen inheritance function. + +To read (write) a window from (to) a file, use the \fBgetwin\fR and +\fBputwin\fR routines [see \fBcurs_util\fR(3X)]. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and \fBOK\fR +upon success. +.SH NOTES +Note that \fBscr_init\fR, \fBscr_set\fR, and \fBscr_restore\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_initscr\fR(3X), \fBcurs_refresh\fR(3X), +\fBcurs_util\fR(3X), \fBsystem\fR(3S) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_scroll.3 b/lib/libncurses/curs_scroll.3 new file mode 100644 index 000000000000..98360324902c --- /dev/null +++ b/lib/libncurses/curs_scroll.3 @@ -0,0 +1,38 @@ +.TH curs_scroll 3X "" +.SH NAME +\fBcurs_scroll\fR: \fBscroll\fR, \fBsrcl\fR, \fBwscrl\fR - scroll a +\fBncurses\fR window +.SH SYNOPSIS +\fB#include \fR + +\fBint scroll(WINDOW *win);\fR +.br +\fBint scrl(int n);\fR +.br +\fBint wscrl(WINDOW *win, int n);\fR +.br +.SH DESCRIPTION +The \fBscroll\fR routine scrolls the window up one line. This involves moving +the lines in the window data structure. As an optimization, if the scrolling +region of the window is the entire screen, the physical screen is scrolled at +the same time. + +With the \fBscrl\fR and \fBwscrl\fR routines, for positive \fIn\fR scroll the +window up \fIn\fR lines (line \fIi\fR+\fIn\fR becomes \fIi\fR); otherwise +scroll the window down \fIn\fR lines. This involves moving the lines in the +window character image structure. The current cursor position is not changed. + +For these functions to work, scrolling must be enabled via \fBscrollok\fR. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion. +.SH NOTES +Note that \fBscrl\fR and \fBscroll\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_outopts\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_slk.3 b/lib/libncurses/curs_slk.3 new file mode 100644 index 000000000000..b67415965f66 --- /dev/null +++ b/lib/libncurses/curs_slk.3 @@ -0,0 +1,85 @@ +.TH curs_slk 3X "" +.SH NAME +\fBcurs_slk\fR: \fBslk_init\fR, \fBslk_set\fR, \fBslk_refresh\fR, +\fBslk_noutrefresh\fR, \fBslk_label\fR, \fBslk_clear\fR, \fBslk_restore\fR, +\fBslk_touch\fR, \fBslk_attron\fR, \fBslk_attrset\fR, \fBslk_attroff\fR - +\fBncurses\fR soft label routines +.SH SYNOPSIS +\fB#include \fR + +\fBint slk_init(int fmt);\fR +.br +\fBint slk_set(int labnum, char *label, int fmt);\fR +.br +\fBint slk_refresh(void);\fR +.br +\fBint slk_noutrefresh(void);\fR +.br +\fBchar *slk_label(int labnum);\fR +.br +\fBint slk_clear(void);\fR +.br +\fBint slk_restore(void);\fR +.br +\fBint slk_touch(void);\fR +.br +\fBint slk_attron(chtype attrs);\fR +.br +\fBint slk_attrset(chtype attrs);\fR +.br +\fBint slk_attroff(chtype attrs);\fR +.br +.SH DESCRIPTION +The slk* functions manipulate the set of soft function-key labels that exist on +many terminals. For those terminals that do not have soft labels, +\fBncurses\fR takes over the bottom line of \fBstdscr\fR, reducing the size of +\fBstdscr\fR and the variable \fBLINES\fR. \fBncurses\fR standardizes on eight +labels of up to eight characters each. + +The \fBslk_init\fR routine must be called before \fBinitscr\fR or \fBnewterm\fR +is called. If \fBinitscr\fR eventually uses a line from \fBstdscr\fR to +emulate the soft labels, then \fIfmt\fR determines how the labels are arranged +on the screen. Setting \fIfmt\fR to \fB0\fR indicates a 3-2-3 arrangement of +the labels; \fB1\fR indicates a 4-4 arrangement. + +With the \fBslk_set\fR routine, \fIlabnum\fR is the label number, from \fB1\fR +to \fB8\fR. \fIlabel\fR is the string to be put on the label, up to eight +characters in length. A null string or a null pointer sets up a blank label. +\fIfmt\fR is either \fB0\fR, \fB1\fR, or \fB2\fR, indicating whether the label +is to be left-justified, centered, or right-justified, respectively, within the +label. + +The \fBslk_refresh\fR and \fBslk_noutrefresh\fR routines correspond to +the \fBwrefresh\fR and \fBwnoutrefresh\fR routines. + +The \fBslk_label\fR routine returns the current label for label number +\fIlabnum\fR, with leading and trailing blanks stripped. + +The \fBslk_clear\fR routine clears the soft labels from the screen. + +The \fBslk_restore\fR routine, restores the soft labels to the screen +after a \fBslk_clear\fR has been performed. + +The \fBslk_touch\fR routine forces all the soft labels to be output +the next time a \fBslk_noutrefresh\fR is performed. + +The \fBslk_attron\fR, \fBslk_attrset\fR and \fBslk_attroff\fR routines +correspond to \fBattron\fR, \fBattrset\fR, and \fBattroff\fR. They +have an effect only if soft labels are simulated on the bottom line of +the screen. +.SH RETURN VALUE +Routines that return an integer return \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion. + +\fBslk_label\fR returns \fBNULL\fR on error. +.SH NOTES +Most applications would use \fBslk_noutrefresh\fR because a +\fBwrefresh\fR is likely to follow soon. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_attr\fR(3X), \fBcurs_initscr\fR(3X), \fBcurs_refresh\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_termatt.3 b/lib/libncurses/curs_termatt.3 new file mode 100644 index 000000000000..fab073ee0f23 --- /dev/null +++ b/lib/libncurses/curs_termatt.3 @@ -0,0 +1,76 @@ +.TH curs_termattrs 3X "" +.SH NAME +\fBcurs_termattrs\fR: \fBbaudrate\fR, \fBerasechar\fR, \fBhas_ic\fR, +\fBhas_il\fR, \fBkillchar\fR, \fBlongname\fR, \fBtermattrs\fR, +\fBtermname\fR - \fBncurses\fR environment query routines +.SH SYNOPSIS +\fB#include \fR + +\fBint baudrate(void);\fR +.br +\fBchar erasechar(void);\fR +.br +\fBint has_ic(void);\fR +.br +\fBint has_il(void);\fR +.br +\fBchar killchar(void);\fR +.br +\fBchar *longname(void);\fR +.br +\fBchtype termattrs(void);\fR +.br +\fBchar *termname(void);\fR +.br +.SH DESCRIPTION +The \fBbaudrate\fR routine returns the output speed of the terminal. The +number returned is in bits per second, for example \fB9600\fR, and is an +integer. + +The \fBerasechar\fR routine returns the user's current erase character. + +The \fBhas_ic\fR routine is true if the terminal has insert- and delete- +character capabilities. + +The \fBhas_il\fR routine is true if the terminal has insert- and delete-line +capabilities, or can simulate them using scrolling regions. This might +be used to determine if it would be appropriate to turn on physical +scrolling using \fBscrollok\fR. + +The \fBkillchar\fR routine returns the user's current line kill character. + +The \fBlongname\fR routine returns a pointer to a static area +containing a verbose description of the current terminal. The maximum +length of a verbose description is 128 characters. It is defined only +after the call to \fBinitscr\fR or \fBnewterm\fR. The area is +overwritten by each call to \fBnewterm\fR and is not restored by +\fBset_term\fR, so the value should be saved between calls to +\fBnewterm\fR if \fBlongname\fR is going to be used with multiple +terminals. + +If a given terminal doesn't support a video attribute that an +application program is trying to use, \fBncurses\fR may substitute a +different video attribute for it. The \fBtermattrs\fR function +returns a logical \fBOR\fR of all video attributes supported by the +terminal. This information is useful when a \fBncurses\fR program +needs complete control over the appearance of the screen. + +The \fBtermname\fR routine returns the value of the environmental +variable \fBTERM\fR (truncated to 14 characters). +.SH RETURN VALUE +\fBlongname\fR and \fBtermname\fR return \fBNULL\fR on error. + +Routines that return an integer return \fBERR\fR upon failure and an integer +value other than \fBERR\fR upon successful completion. +.SH BUGS +The \fBtermattr\fR entry point is not implemented in ncurses 1.8.1. +.SH NOTES +Note that \fBtermattrs\fR may be a macro. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_initscr\fR(3X), \fBcurs_outopts\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_touch.3 b/lib/libncurses/curs_touch.3 new file mode 100644 index 000000000000..8fe73b8f4321 --- /dev/null +++ b/lib/libncurses/curs_touch.3 @@ -0,0 +1,57 @@ +.TH curs_touch 3X "" +.SH NAME +\fBcurs_touch\fR: \fBtouchwin\fR, \fBtouchline\fR, \fBuntouchwin\fR, +\fBwtouchln\fR, \fBis_linetouched\fR, \fBis_wintouched\fR - +\fBncurses\fR refresh control routines +.SH SYNOPSIS +\fB#include \fR +.br +\fBint touchwin(WINDOW *win);\fR +.br +\fBint touchline(WINDOW *win, int start, int count);\fR +.br +\fBint untouchwin(WINDOW *win);\fR +.br +\fBint wtouchln(WINDOW *win, int y, int n, int changed);\fR +.br +\fBint is_linetouched(WINDOW *win, int line);\fR +.br +\fBint is_wintouched(WINDOW *win);\fR +.br +.SH DESCRIPTION +The \fBtouchwin\fR and \fBtouchline\fR routines throw away all +optimization information about which parts of the window have been +touched, by pretending that the entire window has been drawn on. This +is sometimes necessary when using overlapping windows, since a change +to one window affects the other window, but the records of which lines +have been changed in the other window do not reflect the change. The +routine \fBtouchline\fR only pretends that \fIcount\fR lines have been +changed, beginning with line \fIstart\fR. + +The \fBuntouchwin\fR routine marks all lines in the window as unchanged since +the last call to \fBwrefresh\fR. + +The \fBwtouchln\fR routine makes \fIn\fR lines in the window, starting +at line \fIy\fR, look as if they have (\fIchanged\fR\fB=1\fR) or have +not (\fIchanged\fR\fB=0\fR) been changed since the last call to +\fBwrefresh\fR. + +The \fBis_linetouched\fR and \fBis_wintouched\fR routines return +\fBTRUE\fR if the specified line/window was modified since the last +call to \fBwrefresh\fR; otherwise they return \fBFALSE\fR. In +addition, \fBis_linetouched\fR returns \fBERR\fR if \fIline\fR is not +valid for the given window. +.SH RETURN VALUE +All routines return the integer \fBERR\fR upon failure and an integer value +other than \fBERR\fR upon successful completion, unless otherwise noted in the +preceding routine descriptions. +.SH NOTES +Note that all routines except \fBwtouchln\fR may be macros. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_refresh\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_util.3 b/lib/libncurses/curs_util.3 new file mode 100644 index 000000000000..70e8d1a3af75 --- /dev/null +++ b/lib/libncurses/curs_util.3 @@ -0,0 +1,82 @@ +.TH curs_util 3X "" +.SH NAME +\fBcurs_util\fR: \fBunctrl\fR, \fBkeyname\fR, \fBfilter\fR, +\fBuse_env\fR, \fBputwin\fR, \fBgetwin\fR, \fBdelay_output\fR, +\fBflushinp\fR - miscellaneous \fBncurses\fR utility routines +.SH SYNOPSIS +\fB#include \fR + +\fBchar *unctrl(chtype c);\fR +.br +\fBchar *keyname(int c);\fR +.br +\fBint filter(void);\fR +.br +\fBvoid use_env(char bool);\fR +.br +\fBint putwin(WINDOW *win, FILE *filep);\fR +.br +\fBWINDOW *getwin(FILE *filep);\fR +.br +\fBint delay_output(int ms);\fR +.br +\fBint flushinp(void);\fR +.br +.SH DESCRIPTION +The \fBunctrl\fR macro expands to a character string which is a printable +representation of the character \fIc\fR. Control characters are displayed in +the \fB^\fR\fIX\fR notation. Printing characters are displayed as is. + +The \fBkeyname\fR routine returns a character string corresponding to +the key \fIc\fR. + +The \fBfilter\fR routine, if used, must be called before \fBinitscr\fR or +\fBnewterm\fR are called. It makes \fBncurses\fR think that there is a +one-line screen. \fBncurses\fR does not use any terminal capabilities +that assume that they know on what line of the screen the cursor is +positioned. + +The \fBuse_env\fR routine, if used, is called before \fBinitscr\fR or +\fBnewterm\fR are called. When called with \fBFALSE\fR as an +argument, the values of \fBlines\fR and \fBcolumns\fR specified in the +\fIterminfo\fR database will be used, even if environment variables +\fBLINES\fR and \fBCOLUMNS\fR (used by default) are set, or if +\fBncurses\fR is running in a window (in which case default behavior +would be to use the window size if \fBLINES\fR and \fBCOLUMNS\fR are +not set). + +The \fBputwin\fR routine writes all data associated with window \fIwin\fR into +the file to which \fIfilep\fR points. This information can be later retrieved +using the \fBgetwin\fR function. + +The \fBgetwin\fR routine reads window related data stored in the file by +\fBputwin\fR. The routine then creates and initializes a new window using that +data. It returns a pointer to the new window. + +The \fBdelay_output\fR routine inserts an \fIms\fR millisecond pause +in output. This routine should not be used extensively because +padding characters are used rather than a CPU pause. + +The \fBflushinp\fR routine throws away any typeahead that has been typed by the +user and has not yet been read by the program. +.SH RETURN VALUE +Except for \fBflushinp\fR, routines that return an integer return +\fBERR\fR upon failure and an integer value other than \fBERR\fR upon +successful completion. + +\fBflushinp\fR always returns \fBOK\fR. + +Routines that return pointers return \fBNULL\fR on error. +.SH BUGS +The \fBfilter\fR and \fBdelay_output\fR entry points are not yet +supported in ncurses 1.8.1. +.SH NOTES +Note that \fBunctrl\fR is a macro, which is defined in <\fBunctrl.h\fR>. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_initscr\fR(3X), \fBcurs_scr_dump\fR(3X). +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curs_window.3 b/lib/libncurses/curs_window.3 new file mode 100644 index 000000000000..919c2f7ef0ba --- /dev/null +++ b/lib/libncurses/curs_window.3 @@ -0,0 +1,119 @@ +.TH curs_window 3X "" +.SH NAME +\fBcurs_window\fR: \fBnewwin\fR, \fBdelwin\fR, \fBmvwin\fR, +\fBsubwin\fR, \fBderwin\fR, \fBmvderwin\fR, \fBdupwin\fR, +\fBwsyncup\fR, \fBsyncok\fR, \fBwcursyncup\fR, \fBwsyncdown\fR - +create \fBncurses\fR windows +.SH SYNOPSIS +\fB#include \fR + +\fBWINDOW *newwin(int nlines, int ncols, int begin_y,\fR + \fBintbegin_x);\fR + +\fBint delwin(WINDOW *win);\fR +.br +\fBint mvwin(WINDOW *win, int y, int x);\fR +.br +\fBWINDOW *subwin(WINDOW *orig, int nlines, int ncols, + int begin_y, int begin_x);\fR +\fBWINDOW *derwin(WINDOW *orig, int nlines, int ncols, + int begin_y, int begin_x);\fR +\fBint mvderwin(WINDOW *win, int par_y, int par_x);\fR +.br +\fBWINDOW *dupwin(WINDOW *win);\fR +.br +\fBvoid wsyncup(WINDOW *win);\fR +.br +\fBint syncok(WINDOW *win, bool bf);\fR +.br +\fBvoid wcursyncup(WINDOW *win);\fR +.br +\fBvoid wsyncdown(WINDOW *win);\fR +.br +.SH DESCRIPTION +The \fBnewwin\fR routine creates and returns a pointer to a new window with the +given number of lines and columns. The upper left-hand corner of the window is +at line \fIbegin\fR_\fIy\fR, column \fIbegin\fR_\fIx\fR. If either +\fInlines\fR or \fIncols\fR is zero, they default to \fBLINES -\fR +\fIbegin\fR_\fIy\fR and \fBCOLS -\fR \fIbegin\fR_\fIx\fR. A new full-screen +window is created by calling \fBnewwin(0,0,0,0)\fR. + +The \fBdelwin\fR routine deletes the named window, freeing all memory +associated with it (it does not actually erase the window's screen +image). Subwindows must be deleted before the main window can be +deleted. + +The \fBmvwin\fR routine moves the window so that the upper left-hand +corner is at position (\fIx\fR, \fIy\fR). If the move would cause the +window to be off the screen, it is an error and the window is not +moved. Moving subwindows is allowed, but should be avoided. + +The \fBsubwin\fR routine creates and returns a pointer to a new window +with the given number of lines, \fInlines\fR, and columns, +\fIncols\fR. The window is at position (\fIbegin\fR_\fIy\fR, +\fIbegin\fR_\fIx\fR) on the screen. (This position is relative to the +screen, and not to the window \fIorig\fR.) The window is made in the +middle of the window \fIorig\fR, so that changes made to one window +will affect both windows. The subwindow shares memory with the window +\fIorig\fR. When using this routine, it is necessary to call +\fBtouchwin\fR or \fBtouchline\fR on \fIorig\fR before calling +\fBwrefresh\fR on the subwindow. + +The \fBderwin\fR routine is the same as \fBsubwin,\fR except that +\fIbegin\fR_\fIy\fR and \fIbegin\fR_\fIx\fR are relative to the origin +of the window \fIorig\fR rather than the screen. There is no +difference between the subwindows and the derived windows. + +The \fBmvderwin\fR routine moves a derived window (or subwindow) +inside its parent window. The screen-relative parameters of the +window are not changed. This routine is used to display different +parts of the parent window at the same physical position on the +screen. + +The \fBdupwin\fR routine creates an exact duplicate of the window \fIwin\fR. + +Each \fBncurses\fR window maintains two data structures: the character +image structure and the status structure. The character image +structure is shared among all windows in the window hierarchy +(\fIi\fR.\fIe\fR., the window with all subwindows). The status +structure, which contains information about individual line changes in +the window, is private to each window. The routine \fBwrefresh\fR +uses the status data structure when performing screen updating. Since +status structures are not shared, changes made to one window in the +hierarchy may not be properly reflected on the screen. + +The routine \fBwsyncup\fR causes the changes in the status structure +of a window to be reflected in the status structures of its ancestors. +If \fBsyncok\fR is called with second argument \fBTRUE\fR then +\fBwsyncup\fR is called automatically whenever there is a change in +the window. + +The routine \fBwcursyncup\fR updates the current cursor position of all the +ancestors of the window to reflect the current cursor position of the +window. + +The routine \fBwsyncdown\fR updates the status structure of the window +to reflect the changes in the status structures of its ancestors. +Applications seldom call this routine because it is called +automatically by \fBwrefresh\fR. +.SH RETURN VALUE +Routines that return an integer return the integer \fBERR\fR upon failure and +an integer value other than \fBERR\fR upon successful completion. + +\fBdelwin\fR returns the integer \fBERR\fR upon failure and \fBOK\fR +upon successful completion. + +Routines that return pointers return \fBNULL\fR on error. +.SH NOTES +If many small changes are made to the window, the \fBwsyncup\fR option could +degrade performance. + +Note that \fBsyncok\fR may be a macro. +.SH SEE ALSO +\fBncurses\fR(3X), \fBcurs_refresh\fR(3X), \fBcurs_touch\fR(3X) +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/curses.priv.h b/lib/libncurses/curses.priv.h new file mode 100644 index 000000000000..604fe7b610ce --- /dev/null +++ b/lib/libncurses/curses.priv.h @@ -0,0 +1,115 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * curses.priv.h + * + * Header file for curses library objects which are private to + * the library. + * + */ + +#include "version.h" + +#ifndef __GNUC__ +#define inline +#endif + +#ifndef NOACTION +#include +typedef struct sigaction sigaction_t; +#else +#include "SigAction.h" +#endif + +#include + +#define min(a,b) ((a) > (b) ? (b) : (a)) +#define max(a,b) ((a) < (b) ? (b) : (a)) + +#define FG(n) ((n) & 0x0f) +#define BG(n) (((n) & 0xf0) >> 4) + +#define CHANGED -1 + +extern WINDOW *newscr; +extern int _coloron; +extern int _isendwin; + +#ifdef TRACE +#define T(a) if (_tracing) _tracef a +extern int _tracing; +#else +#define T(a) +#endif + +extern int _outc(char); +extern void init_acs(void); +extern void tstp(int); +extern WINDOW *makenew(int, int, int, int); +extern int timed_wait(int fd, int wait, int *timeleft); + +struct try { + struct try *child; /* ptr to child. NULL if none */ + struct try *sibling; /* ptr to sibling. NULL if none */ + unsigned char ch; /* character at this node */ + unsigned short value; /* code of string so far. 0 if none. */ +}; + +/* + * Structure for soft labels. + */ + +typedef struct { + char dirty; /* all labels have changed */ + char hidden; /* soft lables are hidden */ + WINDOW *win; + struct slk_ent { + char text[9]; /* text for the label */ + char form_text[9]; /* formatted text (left/center/...) */ + int x; /* x coordinate of this field */ + char dirty; /* this label has changed */ + char visible; /* field is visible */ + } ent[8]; +} SLK; + +#define FIFO_SIZE 32 + +struct screen { + FILE *_ifp; /* input file ptr for this terminal */ + FILE *_ofp; /* output file ptr for this terminal */ +#ifdef MYTINFO + struct _terminal *_term; +#else + struct term *_term; /* used by terminfo stuff */ +#endif + WINDOW *_curscr; /* windows specific to a given terminal */ + WINDOW *_newscr; + struct try *_keytry; /* "Try" for use with keypad mode */ + unsigned int _fifo[FIFO_SIZE]; /* Buffer for pushed back characters */ + signed char _fifohead, + _fifotail, + _fifopeek; + int _cursrow; /* Row and column of physical cursor */ + int _curscol; + bool _nl; /* True if NL -> CR/NL is on */ + bool _raw; /* True if in raw mode */ + int _cbreak; /* 1 if in cbreak mode */ + /* > 1 if in halfdelay mode */ + bool _echo; /* True if echo on */ + bool _nlmapping; /* True if terminal is really doing */ + /* NL mapping (fn of raw and nl) */ + SLK *_slk; /* ptr to soft key struct / NULL */ + int _costs[9]; /* costs of cursor movements for mvcur */ + int _costinit; /* flag wether costs[] is initialized */ +}; + +extern struct screen *SP; + +extern int _slk_format; /* format specified in slk_init() */ + +#define MAXCOLUMNS 135 +#define MAXLINES 66 +#define UNINITIALISED ((struct try * ) -1) diff --git a/lib/libncurses/keys.list b/lib/libncurses/keys.list new file mode 100644 index 000000000000..e766f32f03b6 --- /dev/null +++ b/lib/libncurses/keys.list @@ -0,0 +1,149 @@ +key_a1 KEY_A1 +key_a3 KEY_A3 +key_b2 KEY_B2 +key_backspace KEY_BACKSPACE +key_beg KEY_BEG +key_btab KEY_BTAB +key_c1 KEY_C1 +key_c3 KEY_C3 +key_cancel KEY_CANCEL +key_catab KEY_CATAB +key_clear KEY_CLEAR +key_close KEY_CLOSE +key_command KEY_COMMAND +key_copy KEY_COPY +key_create KEY_CREATE +key_ctab KEY_CTAB +key_dc KEY_DC +key_dl KEY_DL +key_down KEY_DOWN +key_eic KEY_EIC +key_end KEY_END +key_enter KEY_ENTER +key_eol KEY_EOL +key_eos KEY_EOS +key_exit KEY_EXIT +key_f0 KEY_F(0) +key_f1 KEY_F(1) +key_f2 KEY_F(2) +key_f3 KEY_F(3) +key_f4 KEY_F(4) +key_f5 KEY_F(5) +key_f6 KEY_F(6) +key_f7 KEY_F(7) +key_f8 KEY_F(8) +key_f9 KEY_F(9) +key_f10 KEY_F(10) +key_f11 KEY_F(11) +key_f12 KEY_F(12) +key_f13 KEY_F(13) +key_f14 KEY_F(14) +key_f15 KEY_F(15) +key_f16 KEY_F(16) +key_f17 KEY_F(17) +key_f18 KEY_F(18) +key_f19 KEY_F(19) +key_f20 KEY_F(20) +key_f21 KEY_F(21) +key_f22 KEY_F(22) +key_f23 KEY_F(23) +key_f24 KEY_F(24) +key_f25 KEY_F(25) +key_f26 KEY_F(26) +key_f27 KEY_F(27) +key_f28 KEY_F(28) +key_f29 KEY_F(29) +key_f30 KEY_F(30) +key_f31 KEY_F(31) +key_f32 KEY_F(32) +key_f33 KEY_F(33) +key_f34 KEY_F(34) +key_f35 KEY_F(35) +key_f36 KEY_F(36) +key_f37 KEY_F(37) +key_f38 KEY_F(38) +key_f39 KEY_F(39) +key_f40 KEY_F(40) +key_f41 KEY_F(41) +key_f42 KEY_F(42) +key_f43 KEY_F(43) +key_f44 KEY_F(44) +key_f45 KEY_F(45) +key_f46 KEY_F(46) +key_f47 KEY_F(47) +key_f48 KEY_F(48) +key_f49 KEY_F(49) +key_f50 KEY_F(50) +key_f51 KEY_F(51) +key_f52 KEY_F(52) +key_f53 KEY_F(53) +key_f54 KEY_F(54) +key_f55 KEY_F(55) +key_f56 KEY_F(56) +key_f57 KEY_F(57) +key_f58 KEY_F(58) +key_f59 KEY_F(59) +key_f60 KEY_F(60) +key_f61 KEY_F(61) +key_f62 KEY_F(62) +key_f63 KEY_F(63) +key_find KEY_FIND +key_help KEY_HELP +key_home KEY_HOME +key_ic KEY_IC +key_il KEY_IL +key_left KEY_LEFT +key_ll KEY_LL +key_mark KEY_MARK +key_message KEY_MESSAGE +key_move KEY_MOVE +key_next KEY_NEXT +key_npage KEY_NPAGE +key_open KEY_OPEN +key_options KEY_OPTIONS +key_ppage KEY_PPAGE +key_previous KEY_PREVIOUS +key_print KEY_PRINT +key_redo KEY_REDO +key_reference KEY_REFERENCE +key_refresh KEY_REFRESH +key_replace KEY_REPLACE +key_restart KEY_RESTART +key_resume KEY_RESUME +key_right KEY_RIGHT +key_save KEY_SAVE +key_sbeg KEY_SBEG +key_scancel KEY_SCANCEL +key_scommand KEY_SCOMMAND +key_scopy KEY_SCOPY +key_screate KEY_SCREATE +key_sdc KEY_SDC +key_sdl KEY_SDL +key_select KEY_SELECT +key_send KEY_SEND +key_seol KEY_SEOL +key_sexit KEY_SEXIT +key_sf KEY_SF +key_sfind KEY_SFIND +key_shelp KEY_SHELP +key_shome KEY_SHOME +key_sic KEY_SIC +key_sleft KEY_SLEFT +key_smessage KEY_SMESSAGE +key_smove KEY_SMOVE +key_snext KEY_SNEXT +key_soptions KEY_SOPTIONS +key_sprevious KEY_SPREVIOUS +key_sprint KEY_SPRINT +key_sr KEY_SR +key_sredo KEY_SREDO +key_sreplace KEY_SREPLACE +key_sright KEY_SRIGHT +key_srsume KEY_SRSUME +key_ssave KEY_SSAVE +key_ssuspend KEY_SSUSPEND +key_stab KEY_STAB +key_sundo KEY_SUNDO +key_suspend KEY_SUSPEND +key_undo KEY_UNDO +key_up KEY_UP diff --git a/lib/libncurses/lib_acs.c b/lib/libncurses/lib_acs.c new file mode 100644 index 000000000000..70fd6d2f6158 --- /dev/null +++ b/lib/libncurses/lib_acs.c @@ -0,0 +1,99 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + + +#include "curses.priv.h" +#include +#include + +/* line graphics */ + + +chtype acs_map[128]; + +void init_acs() +{ + +/* + ACS_ULCORNER (acs_map['l']) + ACS_LLCORNER (acs_map['m']) + ACS_URCORNER (acs_map['k']) + ACS_LRCORNER (acs_map['j']) + ACS_RTEE (acs_map['u']) + ACS_LTEE (acs_map['t']) + ACS_BTEE (acs_map['v']) + ACS_TTEE (acs_map['w']) + ACS_HLINE (acs_map['q']) + ACS_VLINE (acs_map['x']) + ACS_PLUS (acs_map['n']) + ACS_S1 (acs_map['o']) scan line 1 + ACS_S9 (acs_map['s']) scan line 9 + ACS_DIAMOND (acs_map['`']) diamond + ACS_CKBOARD (acs_map['a']) checker board (stipple) + ACS_DEGREE (acs_map['f']) degree symbol + ACS_PLMINUS (acs_map['g']) plus/minus + ACS_BULLET (acs_map['~']) bullet + ACS_LARROW (acs_map[',']) arrow pointing left + ACS_RARROW (acs_map['+']) arrow pointing right + ACS_DARROW (acs_map['.']) arrow pointing down + ACS_UARROW (acs_map['-']) arrow pointing up + ACS_BOARD (acs_map['h']) board of squares + ACS_LANTERN (acs_map['I']) lantern symbol + ACS_BLOCK (acs_map['0']) solid square block +*/ + + T(("initializing ACS map")); + + acs_map['l'] = acs_map['m'] = acs_map['k'] = acs_map['j'] = + acs_map['u'] = acs_map['t'] = acs_map['v'] = acs_map['w'] = (chtype)'+' & A_CHARTEXT; + acs_map['q'] = (chtype)'-' & A_CHARTEXT; + acs_map['x'] = (chtype)'|' & A_CHARTEXT; + acs_map['n'] = (chtype)'+' & A_CHARTEXT; + acs_map['o'] = (chtype)'~' & A_CHARTEXT; + acs_map['s'] = (chtype)'_' & A_CHARTEXT; + acs_map['`'] = (chtype)'+' & A_CHARTEXT; + acs_map['a'] = (chtype)':' & A_CHARTEXT; + acs_map['f'] = (chtype)'\'' & A_CHARTEXT; + acs_map['g'] = (chtype)'#' & A_CHARTEXT; + acs_map['~'] = (chtype)'o' & A_CHARTEXT; + acs_map[','] = (chtype)'<' & A_CHARTEXT; + acs_map['+'] = (chtype)'>' & A_CHARTEXT; + acs_map['.'] = (chtype)'v' & A_CHARTEXT; + acs_map['-'] = (chtype)'^' & A_CHARTEXT; + acs_map['h'] = (chtype)'#' & A_CHARTEXT; + acs_map['I'] = (chtype)'#' & A_CHARTEXT; + acs_map['0'] = (chtype)'#' & A_CHARTEXT; + + if (ena_acs != NULL) + tputs(ena_acs, 1, _outc); + + if (acs_chars != NULL) { + int i = 0; + int length = strlen(acs_chars); + + while (i < length) + switch (acs_chars[i]) { + case 'l':case 'm':case 'k':case 'j': + case 'u':case 't':case 'v':case 'w': + case 'q':case 'x':case 'n':case 'o': + case 's':case '`':case 'a':case 'f': + case 'g':case '~':case ',':case '+': + case '.':case '-':case 'h':case 'I': + case '0': + acs_map[(unsigned int)(unsigned char)acs_chars[i]] = + (acs_chars[++i] & A_CHARTEXT) | A_ALTCHARSET; + default: + i++; + break; + } + } +#ifdef TRACE + else { + if (_tracing) + _tracef("acsc not defined, using default mapping"); + } +#endif +} + diff --git a/lib/libncurses/lib_addch.c b/lib/libncurses/lib_addch.c new file mode 100644 index 000000000000..50c4ae7bac0a --- /dev/null +++ b/lib/libncurses/lib_addch.c @@ -0,0 +1,86 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_addch.c +** +** The routine waddch(). +** +*/ + +#include "curses.priv.h" +#include "unctrl.h" + +int +waddch(WINDOW *win, chtype c) +{ +int x, y; +int newx; +chtype ch = c; + +#if 0 + /* enabling this causes tons of tracing output + and slow ncurses down to a crawl */ + T(("waddch(%x,%c (%x)) called", win, ch&A_CHARTEXT, ch)); +#endif + + x = win->_curx; + y = win->_cury; + + if (y > win->_maxy || x > win->_maxx || y < 0 || x < 0) + return(ERR); + + switch (ch&A_CHARTEXT) { + case '\t': + for (newx = x + (8 - (x & 07)); x < newx; x++) + if (waddch(win, ' ') == ERR) + return(ERR); + return(OK); + case '\n': + wclrtoeol(win); + x = 0; + goto newline; + case '\r': + x = 0; + break; + case '\b': + if (--x < 0) + x = 0; + break; + default: + if (ch < ' ') + return(waddstr(win, unctrl(ch))); + + ch |= win->_attrs; + + if (win->_line[y][x] != ch) { + if (win->_firstchar[y] == _NOCHANGE) + win->_firstchar[y] = win->_lastchar[y] = x; + else if (x < win->_firstchar[y]) + win->_firstchar[y] = x; + else if (x > win->_lastchar[y]) + win->_lastchar[y] = x; + + } + + win->_line[y][x++] = ch; + if (x > win->_maxx) { + x = 0; +newline: + y++; + if (y > win->_regbottom) { + y--; + if (win->_scroll) + scroll(win); + } + } + break; + } + + win->_curx = x; + win->_cury = y; + + return(OK); +} diff --git a/lib/libncurses/lib_addstr.c b/lib/libncurses/lib_addstr.c new file mode 100644 index 000000000000..007598cdb308 --- /dev/null +++ b/lib/libncurses/lib_addstr.c @@ -0,0 +1,56 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_addstr.c +* +** The routines waddnstr(), waddchnstr(). +** +*/ + +#include "curses.priv.h" + +int +waddnstr(WINDOW *win, char *str, int n) +{ + T(("waddnstr(%x,%s,%d) called", win, str, n)); + + if (str == NULL) + return ERR; + + if (n < 0) { + while (*str != '\0') { + if (waddch(win, (unsigned char)*str++) == ERR) + return(ERR); + } + return OK; + } + + while((n-- > 0) && (*str != '\0')) { + if (waddch(win, (unsigned char)*str++) == ERR) + return ERR; + } + return OK; +} + +int +waddchnstr(WINDOW *win, chtype *str, int n) +{ + T(("waddchnstr(%x,%x,%d) called", win, str, n)); + + if (n < 0) { + while (*str) { + if (waddch(win, *str++) == ERR) + return(ERR); + } + return OK; + } + + while(n-- > 0) { + if (waddch(win, *str++) == ERR) + return ERR; + } + return OK; +} diff --git a/lib/libncurses/lib_beep.c b/lib/libncurses/lib_beep.c new file mode 100644 index 000000000000..7837ac142a81 --- /dev/null +++ b/lib/libncurses/lib_beep.c @@ -0,0 +1,56 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * beep.c + * + * Routines beep() and flash() + * + */ + +#include "curses.priv.h" +#include + +/* + * beep() + * + * Sound the current terminal's audible bell if it has one. If not, + * flash the screen if possible. + * + */ + +int beep() +{ + T(("beep() called")); + + /* should make sure that we are not in altchar mode */ + if (bell) + return(tputs(bell, 1, _outc)); + else if (flash_screen) + return(tputs(flash_screen, 1, _outc)); + else + return(ERR); +} + +/* + * flash() + * + * Flash the current terminal's screen if possible. If not, + * sound the audible bell if one exists. + * + */ + +int flash() +{ + T(("flash() called")); + + /* should make sure that we are not in altchar mode */ + if (flash_screen) + return(tputs(flash_screen, 1, _outc)); + else if (bell) + return(tputs(bell, 1, _outc)); + else + return(ERR); +} diff --git a/lib/libncurses/lib_box.c b/lib/libncurses/lib_box.c new file mode 100644 index 000000000000..ca4e03270721 --- /dev/null +++ b/lib/libncurses/lib_box.c @@ -0,0 +1,131 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_box.c +** +** line drawing routines: +** wborder() +** whline() +** wvline() +** +*/ + +#include "curses.priv.h" + +int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, + chtype bs, chtype tl, chtype tr, chtype bl, chtype br) +{ +int i; +int endx, endy; + + T(("wborder() called")); + + if (ls == 0) ls = ACS_VLINE; + if (rs == 0) rs = ACS_VLINE; + if (ts == 0) ts = ACS_HLINE; + if (bs == 0) bs = ACS_HLINE; + if (tl == 0) tl = ACS_ULCORNER; + if (tr == 0) tr = ACS_URCORNER; + if (bl == 0) bl = ACS_LLCORNER; + if (br == 0) br = ACS_LRCORNER; + + ls |= win->_attrs; + rs |= win->_attrs; + ts |= win->_attrs; + bs |= win->_attrs; + tl |= win->_attrs; + tr |= win->_attrs; + bl |= win->_attrs; + br |= win->_attrs; + + T(("using %x, %x, %x, %x, %x, %x, %x, %x", ls, rs, ts, bs, tl, tr, bl, br)); + + endx = win->_maxx; + endy = win->_maxy; + + for (i = 0; i <= endx; i++) { + win->_line[0][i] = ts; + win->_line[endy][i] = bs; + } + win->_firstchar[endy] = win->_firstchar[0] = 0; + win->_lastchar[endy] = win->_lastchar[0] = endx; + + for (i = 0; i <= endy; i++) { + win->_line[i][0] = ls; + win->_line[i][endx] = rs; + win->_firstchar[i] = 0; + win->_lastchar[i] = endx; + } + win->_line[0][0] = tl; + win->_line[0][endx] = tr; + win->_line[endy][0] = bl; + win->_line[endy][endx] = br; + +#if 0 + if (! win->_scroll && (win->_flags & _SCROLLWIN)) + fp[0] = fp[endx] = lp[0] = lp[endx] = ' '; +#endif + + return OK; +} + +int whline(WINDOW *win, chtype ch, int n) +{ +int line; +int start; +int end; + + T(("whline(%x,%x,%d) called", win, ch, n)); + + line = win->_cury; + start = win->_curx; + end = start + n - 1; + if (end > win->_maxx) + end = win->_maxx; + + if (win->_firstchar[line] == _NOCHANGE || win->_firstchar[line] > start) + win->_firstchar[line] = start; + if (win->_lastchar[line] == _NOCHANGE || win->_lastchar[line] < start) + win->_lastchar[line] = end; + + if (ch == 0) + ch = ACS_HLINE; + while ( end >= start) { + win->_line[line][end] = ch | win->_attrs; + end--; + } + + return OK; +} + +int wvline(WINDOW *win, chtype ch, int n) +{ +int row, col; +int end; + + T(("wvline(%x,%x,%d) called", win, ch, n)); + + row = win->_cury; + col = win->_curx; + end = row + n - 1; + if (end > win->_maxy) + end = win->_maxy; + + if (ch == 0) + ch = ACS_VLINE; + + while(end >= row) { + win->_line[end][col] = ch | win->_attrs; + if (win->_firstchar[end] == _NOCHANGE || win->_firstchar[end] > col) + win->_firstchar[end] = col; + if (win->_lastchar[end] == _NOCHANGE || win->_lastchar[end] < col) + win->_lastchar[end] = col; + end--; + } + + return OK; +} + diff --git a/lib/libncurses/lib_clear.c b/lib/libncurses/lib_clear.c new file mode 100644 index 000000000000..c82db9bc13ec --- /dev/null +++ b/lib/libncurses/lib_clear.c @@ -0,0 +1,24 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_clear.c +** +** The routine wclear(). +** +*/ + +#include "curses.priv.h" + +int wclear(WINDOW *win) +{ + T(("wclear(%x) called", win)); + + werase(win); + + win->_clear = TRUE; + + return OK; +} diff --git a/lib/libncurses/lib_clrbot.c b/lib/libncurses/lib_clrbot.c new file mode 100644 index 000000000000..fa48db8a8ebd --- /dev/null +++ b/lib/libncurses/lib_clrbot.c @@ -0,0 +1,53 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_clrbot.c +** +** The routine wclrtobot(). +** +*/ + +#include "curses.priv.h" + +#define BLANK ' '|A_NORMAL + +int wclrtobot(WINDOW *win) +{ +chtype *ptr, *end, *maxx = NULL; +int y, startx, minx; + + T(("wclrtobot(%x) called", win)); + + startx = win->_curx; + + T(("clearing from y = %d to y = %d with maxx = %d", win->_cury, win->_maxy, win->_maxx)); + + for (y = win->_cury; y <= win->_maxy; y++) { + minx = _NOCHANGE; + end = &win->_line[y][win->_maxx]; + + for (ptr = &win->_line[y][startx]; ptr <= end; ptr++) { + if (*ptr != BLANK) { + maxx = ptr; + if (minx == _NOCHANGE) + minx = ptr - win->_line[y]; + *ptr = BLANK; + } + } + + if (minx != _NOCHANGE) { + if (win->_firstchar[y] > minx + || win->_firstchar[y] == _NOCHANGE) + win->_firstchar[y] = minx; + + if (win->_lastchar[y] < maxx - win->_line[y]) + win->_lastchar[y] = maxx - win->_line[y]; + } + + startx = 0; + } + return OK; +} diff --git a/lib/libncurses/lib_clreol.c b/lib/libncurses/lib_clreol.c new file mode 100644 index 000000000000..a22d6b2f9cc2 --- /dev/null +++ b/lib/libncurses/lib_clreol.c @@ -0,0 +1,48 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_clreol.c +** +** The routine wclrtoeol(). +** +*/ + +#include "curses.priv.h" + +#define BLANK ' '|A_NORMAL + +int wclrtoeol(WINDOW *win) +{ +chtype *maxx, *ptr, *end; +int y, x, minx; + + T(("wclrtoeol(%x) called", win)); + + y = win->_cury; + x = win->_curx; + + end = &win->_line[y][win->_maxx]; + minx = _NOCHANGE; + maxx = &win->_line[y][x]; + + for (ptr = maxx; ptr <= end; ptr++) { + if (*ptr != BLANK) { + maxx = ptr; + if (minx == _NOCHANGE) + minx = ptr - win->_line[y]; + *ptr = BLANK; + } + } + + if (minx != _NOCHANGE) { + if (win->_firstchar[y] > minx || win->_firstchar[y] == _NOCHANGE) + win->_firstchar[y] = minx; + + if (win->_lastchar[y] < maxx - win->_line[y]) + win->_lastchar[y] = maxx - win->_line[y]; + } + return(OK); +} diff --git a/lib/libncurses/lib_color.c b/lib/libncurses/lib_color.c new file mode 100644 index 000000000000..8ba3ad993ef1 --- /dev/null +++ b/lib/libncurses/lib_color.c @@ -0,0 +1,107 @@ +/* This work is copyrighted. See COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* lib_color.c + * + * Handles color emulation of SYS V curses + * + */ + +#include "curses.priv.h" +#include + +int COLOR_PAIRS; +int COLORS; +unsigned char color_pairs[64]; + +int _coloron = 0; + +int start_color() +{ + T(("start_color() called.")); + + if (orig_pair != NULL) + tputs(orig_pair, 1, _outc); + else return ERR; + if (max_pairs != -1) + COLOR_PAIRS = max_pairs; + else return ERR; + if (max_colors != -1) + COLORS = max_colors; + else return ERR; + _coloron = 1; + + T(("started color: COLORS = %d, COLOR_PAIRS = %d", COLORS, COLOR_PAIRS)); + + return OK; +} + +int init_pair(short pair, short f, short b) +{ + T(("init_pair( %d, %d, %d )", pair, f, b)); + + if ((pair < 1) || (pair > COLOR_PAIRS)) + return ERR; + if ((f < 0) || (f >= COLORS) || (b < 0) || (b >= COLORS)) + return ERR; + + /* still to do: + if pair was initialized before a screen update is performed + replacing original pair colors with the new ones + */ + + color_pairs[pair] = ( (f & 0x0f) | (b & 0x0f) << 4 ); + + return color_pairs[pair]; +} + +int init_color(short color, short r, short g, short b) +{ + if (initialize_color != NULL) { + if (color < 0 || color >= COLORS) + return ERR; + if (hue_lightness_saturation == TRUE) + if (r < 0 || r > 360 || g < 0 || g > 100 || b < 0 || b > 100) + return ERR; + if (hue_lightness_saturation == FALSE) + if (r < 0 || r > 1000 || g < 0 || g > 1000 || b < 0 || b > 1000) + return ERR; + + tputs(tparm(initialize_color, color, r, g, b), 1, _outc); + return OK; + } + + return ERR; +} + +bool can_change_color() +{ + return can_change; +} + +int has_colors() +{ + return ((orig_pair != NULL) && (max_colors != -1) && (max_pairs != -1) + && + (((set_foreground != NULL) && (set_background != NULL)) || + ((set_a_foreground != NULL) && (set_a_background != NULL))) + ); +} + +int color_content(short color, short *r, short *g, short *b) +{ + return ERR; +} + +int pair_content(short pair, short *f, short *b) +{ + + if ((pair < 1) || (pair > COLOR_PAIRS)) + return ERR; + *f = color_pairs[pair] & 0x0f; + *b = color_pairs[pair] & 0xf0; + *b >>= 4; + return OK; +} + diff --git a/lib/libncurses/lib_delch.c b/lib/libncurses/lib_delch.c new file mode 100644 index 000000000000..5c62acb38bd9 --- /dev/null +++ b/lib/libncurses/lib_delch.c @@ -0,0 +1,38 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_delch.c +** +** The routine wdelch(). +** +*/ + +#include "curses.priv.h" +#include + +int wdelch(WINDOW *win) +{ +chtype *temp1, *temp2; +chtype *end; + + T(("wdelch(%x) called", win)); + + end = &win->_line[win->_cury][win->_maxx]; + temp2 = &win->_line[win->_cury][win->_curx + 1]; + temp1 = temp2 - 1; + + while (temp1 < end) + *temp1++ = *temp2++; + + *temp1 = ' ' | win->_attrs; + + win->_lastchar[win->_cury] = win->_maxx; + + if (win->_firstchar[win->_cury] == _NOCHANGE + || win->_firstchar[win->_cury] > win->_curx) + win->_firstchar[win->_cury] = win->_curx; + return OK; +} diff --git a/lib/libncurses/lib_deleteln.c b/lib/libncurses/lib_deleteln.c new file mode 100644 index 000000000000..d218eb49aadc --- /dev/null +++ b/lib/libncurses/lib_deleteln.c @@ -0,0 +1,48 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_deleteln.c +** +** The routine wdeleteln(). +** +*/ + +#include "curses.priv.h" +#include + +int wdeleteln(WINDOW *win) +{ +chtype *end, *temp; +int y, touched = 0; + + T(("wdeleteln(%x) called", win)); + + temp = win->_line[win->_cury]; + + if (win->_idlok && (delete_line != NULL)) { + putp(delete_line); + touched = 1; + } + + for (y = win->_cury; y < win->_regbottom; y++) { + win->_line[y] = win->_line[y+1]; + + if (!touched) { + win->_firstchar[y] = 0; + win->_lastchar[y] = win->_maxx; + } + } + + win->_line[win->_regbottom] = temp; + if (!touched) { + win->_firstchar[win->_regbottom] = 0; + win->_lastchar[win->_regbottom] = win->_maxx; + } + + for (end = &(temp[win->_maxx]); temp <= end; ) + *temp++ = ' ' | win->_attrs; + return OK; +} diff --git a/lib/libncurses/lib_delwin.c b/lib/libncurses/lib_delwin.c new file mode 100644 index 000000000000..e84e2163c097 --- /dev/null +++ b/lib/libncurses/lib_delwin.c @@ -0,0 +1,35 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_delwin.c +** +** The routine delwin(). +** +*/ + +#include +#include "curses.priv.h" + +int delwin(WINDOW *win) +{ +int i; + + T(("delwin(%x) called", win)); + + if (! (win->_flags & _SUBWIN)) { + for (i = 0; i < win->_maxy && win->_line[i]; i++) + free(win->_line[i]); + } + + free(win->_firstchar); + free(win->_lastchar); + free(win->_line); + free(win); + + touchwin(curscr); + + return(OK); +} diff --git a/lib/libncurses/lib_doupdate.c b/lib/libncurses/lib_doupdate.c new file mode 100644 index 000000000000..f85d09934392 --- /dev/null +++ b/lib/libncurses/lib_doupdate.c @@ -0,0 +1,527 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/*----------------------------------------------------------------- + * + * lib_doupdate.c + * + * The routine doupdate() and its dependents + * + *-----------------------------------------------------------------*/ + +#include +#include +#include "curses.priv.h" +#include +#ifdef SVR4_ACTION +#define _POSIX_SOURCE +#endif +#include + +static void ClrUpdate( WINDOW *scr ); +static void TransformLine( int lineno ); +static void NoIDcTransformLine( int lineno ); +static void IDcTransformLine( int lineno ); +static void ClearScreen( void ); +static void InsStr( chtype *line, int count ); +static void DelChar( int count ); + +static inline void PutAttrChar(chtype ch) +{ + if (curscr->_attrs != (ch & (chtype)A_ATTRIBUTES)) { + curscr->_attrs = ch & (chtype)A_ATTRIBUTES; + vidputs(curscr->_attrs, _outc); + } + putc(ch & A_CHARTEXT, SP->_ofp); +} + +static int LRCORNER = FALSE; + +static inline void PutChar(chtype ch) +{ + T(("puttin %x", ch)); + if (LRCORNER == TRUE) { + if (SP->_curscol == columns-2) { + PutAttrChar(newscr->_line[lines-1][columns-2]); + SP->_curscol++; + return; + } else if (SP->_curscol == columns-1) { + int i = lines; + int j = columns -1; + if (cursor_left) + tputs(cursor_left, 1, _outc); + else + mvcur(-1, -1, i-1, j); + if (enter_insert_mode && exit_insert_mode) { + tputs(enter_insert_mode, 1, _outc); + PutAttrChar(newscr->_line[i-1][j]); + tputs(exit_insert_mode, 1, _outc); + } else if (insert_character) { + tputs(insert_character, 1, _outc); + PutAttrChar(newscr->_line[i-1][j]); + } + return; + } + } + PutAttrChar(ch); + SP->_curscol++; + if (SP->_curscol >= columns) { + if (auto_right_margin) { + SP->_curscol = 0; + SP->_cursrow++; + } else { + SP->_curscol--; + } + } +} + +static inline void GoTo(int row, int col) +{ + mvcur(SP->_cursrow, SP->_curscol, row, col); + SP->_cursrow = row; + SP->_curscol = col; +} + +int _outc(char ch) +{ + putc(ch, SP->_ofp); + return OK; +} + +int doupdate(void) +{ +int i; +sigaction_t act, oact; + + T(("doupdate() called")); + + act.sa_handler = SIG_IGN; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; + sigaction(SIGTSTP, &act, &oact); + + if (_isendwin == 1) { + T(("coming back from shell mode")); + reset_prog_mode(); + /* is this necessary? */ + if (enter_alt_charset_mode) + init_acs(); + newscr->_clear = TRUE; + _isendwin = 0; + } + + if (curscr->_clear) { /* force refresh ? */ + T(("clearing and updating curscr")); + ClrUpdate(curscr); /* yes, clear all & update */ + curscr->_clear = FALSE; /* reset flag */ + } else { + if (newscr->_clear) { + T(("clearing and updating newscr")); + ClrUpdate(newscr); + newscr->_clear = FALSE; + } else { + T(("Transforming lines")); + for (i = 0; i < lines ; i++) { + if(newscr->_firstchar[i] != _NOCHANGE) + TransformLine(i); + } + } + } + T(("marking screen as updated")); + for (i = 0; i < lines; i++) { + newscr->_firstchar[i] = _NOCHANGE; + newscr->_lastchar[i] = _NOCHANGE; + } + + curscr->_curx = newscr->_curx; + curscr->_cury = newscr->_cury; + + GoTo(curscr->_cury, curscr->_curx); + + /* perhaps we should turn attributes off here */ + + if (!(curscr->_attrs & A_NORMAL)) + vidattr(curscr->_attrs = A_NORMAL); + + fflush(SP->_ofp); + + sigaction(SIGTSTP, &oact, NULL); + + return OK; +} + +static int move_right_cost = -1; + +static int countc(char c) +{ + return(move_right_cost++); +} + +/* +** ClrUpdate(scr) +** +** Update by clearing and redrawing the entire screen. +** +*/ + +#define BLANK ' '|A_NORMAL + +static void ClrUpdate(WINDOW *scr) +{ +int i = 0, j = 0; +int lastNonBlank; + + T(("ClrUpdate(%x) called", scr)); + if (back_color_erase) { + T(("back_color_erase, turning attributes off")); + vidattr(A_NORMAL); + } + ClearScreen(); + + if ((move_right_cost == -1) && parm_right_cursor) { + move_right_cost = 0; + tputs(tparm(parm_right_cursor, 10), 1, countc); + } + + T(("updating screen from scratch")); + for (i = 0; i < lines; i++) { + LRCORNER = FALSE; + lastNonBlank = columns - 1; + + while (scr->_line[i][lastNonBlank] == BLANK ) + lastNonBlank--; + + T(("updating line %d upto %d", i, lastNonBlank)); + + /* check if we are at the lr corner */ + if (i == lines-1) + if ((auto_right_margin) && !(eat_newline_glitch) && + (lastNonBlank == columns-1) && !(scr->_scroll)) + { + T(("Lower-right corner needs special handling")); + LRCORNER = TRUE; + } + + for (j = 0; j <= lastNonBlank; j++) { + if (parm_right_cursor) { + static int inspace = 0; + + T(("trying to use parm_right_cursor")); + if ((scr->_line[i][j]) == BLANK) { + inspace++; + continue; + } else if(inspace) { + if (inspace < move_right_cost) { + for (; inspace > 0; inspace--) + PutChar(scr->_line[i][j-1]); + } else { + tputs(tparm(parm_right_cursor, inspace), 1, _outc); + } + inspace = 0; + } + } + PutChar(scr->_line[i][j]); + } + /* move cursor to the next line */ + if ((!auto_right_margin) || (lastNonBlank < columns - 1) || + (auto_right_margin && eat_newline_glitch && lastNonBlank == columns-1)) + { + SP->_curscol = (lastNonBlank < 0) ? 0 : lastNonBlank; + SP->_cursrow++; + GoTo(i+1, 0); + } + } + + + if (scr != curscr) { + for (i = 0; i < lines ; i++) + for (j = 0; j < columns; j++) + curscr->_line[i][j] = scr->_line[i][j]; + } +} + +/* +** TransformLine(lineno) +** +** Call either IDcTransformLine or NoIDcTransformLine to do the +** update, depending upon availability of insert/delete character. +*/ + +static void TransformLine(int lineno) +{ + + T(("TransformLine(%d) called",lineno)); + + if ( (insert_character || (enter_insert_mode && exit_insert_mode)) + && delete_character) + IDcTransformLine(lineno); + else + NoIDcTransformLine(lineno); +} + + + +/* +** NoIDcTransformLine(lineno) +** +** Transform the given line in curscr to the one in newscr, without +** using Insert/Delete Character. +** +** firstChar = position of first different character in line +** lastChar = position of last different character in line +** +** overwrite all characters between firstChar and lastChar. +** +*/ + +static void NoIDcTransformLine(int lineno) +{ +int firstChar, lastChar; +chtype *newLine = newscr->_line[lineno]; +chtype *oldLine = curscr->_line[lineno]; +int k; +int attrchanged = 0; + + T(("NoIDcTransformLine(%d) called", lineno)); + + firstChar = 0; + while (firstChar < columns - 1 && newLine[firstChar] == oldLine[firstChar]) { + if(ceol_standout_glitch) { + if((newLine[firstChar] & (chtype)A_ATTRIBUTES) != (oldLine[firstChar] & (chtype)A_ATTRIBUTES)) + attrchanged = 1; + } + firstChar++; + } + + T(("first char at %d is %x", firstChar, newLine[firstChar])); + if (firstChar > columns) + return; + + if(ceol_standout_glitch && attrchanged) { + firstChar = 0; + lastChar = columns - 1; + GoTo(lineno, firstChar); + if(clr_eol) { + if (back_color_erase) { + T(("back_color_erase, turning attributes off")); + vidattr(A_NORMAL); + } + tputs(clr_eol, 1, _outc); + } + } else { + lastChar = columns - 1; + while (lastChar > firstChar && newLine[lastChar] == oldLine[lastChar]) + lastChar--; + GoTo(lineno, firstChar); + } + + /* check if we are at the lr corner */ + if (lineno == lines-1) + if ((auto_right_margin) && !(eat_newline_glitch) && + (lastChar == columns-1) && !(curscr->_scroll)) + { + T(("Lower-right corner needs special handling")); + LRCORNER = TRUE; + } + + T(("updating chars %d to %d", firstChar, lastChar)); + for (k = firstChar; k <= lastChar; k++) { + PutChar(newLine[k]); + oldLine[k] = newLine[k]; + } +} + +/* +** IDcTransformLine(lineno) +** +** Transform the given line in curscr to the one in newscr, using +** Insert/Delete Character. +** +** firstChar = position of first different character in line +** oLastChar = position of last different character in old line +** nLastChar = position of last different character in new line +** +** move to firstChar +** overwrite chars up to min(oLastChar, nLastChar) +** if oLastChar < nLastChar +** insert newLine[oLastChar+1..nLastChar] +** else +** delete oLastChar - nLastChar spaces +*/ + +static void IDcTransformLine(int lineno) +{ +int firstChar, oLastChar, nLastChar; +chtype *newLine = newscr->_line[lineno]; +chtype *oldLine = curscr->_line[lineno]; +int k, n; +int attrchanged = 0; + + T(("IDcTransformLine(%d) called", lineno)); + + if(ceol_standout_glitch && clr_eol) { + firstChar = 0; + while(firstChar < columns) { + if((newLine[firstChar] & (chtype)A_ATTRIBUTES) != (oldLine[firstChar] & (chtype)A_ATTRIBUTES)) + attrchanged = 1; + firstChar++; + } + } + + firstChar = 0; + + if (attrchanged) { + GoTo(lineno, firstChar); + if (back_color_erase) { + T(("back_color_erase, turning attributes off")); + vidattr(A_NORMAL); + } + tputs(clr_eol, 1, _outc); + for( k = 0 ; k <= (columns-1) ; k++ ) + PutChar(newLine[k]); + } else { + while (firstChar < columns && + newLine[firstChar] == oldLine[firstChar]) + firstChar++; + + if (firstChar >= columns) + return; + + oLastChar = columns - 1; + while (oLastChar > firstChar && oldLine[oLastChar] == ' ') + oLastChar--; + + nLastChar = columns - 1; + while (nLastChar > firstChar && newLine[nLastChar] == ' ') + nLastChar--; + + if((nLastChar == firstChar) && clr_eol) { + GoTo(lineno, firstChar); + if (back_color_erase) { + T(("back_color_erase, turning attributes off")); + vidattr(A_NORMAL); + } + tputs(clr_eol,1,_outc); + if(newLine[firstChar] != ' ' ) + PutChar(newLine[firstChar]); + } else if( newLine[nLastChar] != oldLine[oLastChar] ) { + n = max( nLastChar , oLastChar ); + + GoTo(lineno, firstChar); + + for( k=firstChar ; k <= n ; k++ ) + PutChar(newLine[k]); + } else { + while (newLine[nLastChar] == oldLine[oLastChar]) { + nLastChar--; + oLastChar--; + } + + n = min(oLastChar, nLastChar); + + GoTo(lineno, firstChar); + + for (k=firstChar; k <= n; k++) + PutChar(newLine[k]); + + if (oLastChar < nLastChar) + InsStr(&newLine[k], nLastChar - oLastChar); + + else if (oLastChar > nLastChar ) + DelChar(oLastChar - nLastChar); + } + } + for (k = firstChar; k < columns; k++) + oldLine[k] = newLine[k]; +} + +/* +** ClearScreen() +** +** Clear the physical screen and put cursor at home +** +*/ + +static void ClearScreen() +{ + + T(("ClearScreen() called")); + + if (clear_screen) { + tputs(clear_screen, 1, _outc); + SP->_cursrow = SP->_curscol = 0; + } else if (clr_eos) { + SP->_cursrow = SP->_curscol = -1; + GoTo(0,0); + + tputs(clr_eos, 1, _outc); + } else if (clr_eol) { + SP->_cursrow = SP->_curscol = -1; + + while (SP->_cursrow < lines) { + GoTo(SP->_cursrow, 0); + tputs(clr_eol, 1, _outc); + } + GoTo(0,0); + } + T(("screen cleared")); +} + + +/* +** InsStr(line, count) +** +** Insert the count characters pointed to by line. +** +*/ + +static void InsStr(chtype *line, int count) +{ + T(("InsStr(%x,%d) called", line, count)); + + if (enter_insert_mode && exit_insert_mode) { + tputs(enter_insert_mode, 1, _outc); + while (count) { + PutChar(*line); + line++; + count--; + } + tputs(exit_insert_mode, 1, _outc); + } else if (parm_ich) { + tputs(tparm(parm_ich, count), 1, _outc); + while (count) { + PutChar(*line); + line++; + count--; + } + } else { + while (count) { + tputs(insert_character, 1, _outc); + PutChar(*line); + line++; + count--; + } + } +} + +/* +** DelChar(count) +** +** Delete count characters at current position +** +*/ + +static void DelChar(int count) +{ + T(("DelChar(%d) called", count)); + + if (parm_dch) { + tputs(tparm(parm_dch, count), 1, _outc); + } else { + while (count--) + tputs(delete_character, 1, _outc); + } +} + diff --git a/lib/libncurses/lib_endwin.c b/lib/libncurses/lib_endwin.c new file mode 100644 index 000000000000..b32af2de5de3 --- /dev/null +++ b/lib/libncurses/lib_endwin.c @@ -0,0 +1,44 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_endwin.c +** +** The routine endwin(). +** +*/ + +#include +#include "curses.priv.h" + +int _isendwin; + +int isendwin() +{ + return _isendwin; +} + +int +endwin() +{ + T(("endwin() called")); + + _isendwin = 1; + + mvcur(-1, -1, lines - 1, 0); + + if (exit_ca_mode) + tputs(exit_ca_mode, 1, _outc); + + if (_coloron == 1) + tputs(orig_pair, 1, _outc); + + if (curscr && (curscr->_attrs != A_NORMAL)) + vidattr(curscr->_attrs = A_NORMAL); + + fflush(SP->_ofp); + + return(reset_shell_mode()); +} diff --git a/lib/libncurses/lib_erase.c b/lib/libncurses/lib_erase.c new file mode 100644 index 000000000000..221a04cd8183 --- /dev/null +++ b/lib/libncurses/lib_erase.c @@ -0,0 +1,50 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_erase.c +** +** The routine werase(). +** +*/ + +#include "curses.priv.h" +#include + +#define BLANK ' ' + +int werase(WINDOW *win) +{ +int y; +chtype *sp, *end, *start, *maxx = NULL; +int minx; + + T(("werase(%x) called", win)); + + for (y = win->_regtop; y <= win->_regbottom; y++) { + minx = _NOCHANGE; + start = win->_line[y]; + end = &start[win->_maxx]; + + maxx = start; + for (sp = start; sp <= end; sp++) { + maxx = sp; + if (minx == _NOCHANGE) + minx = sp - start; + *sp = BLANK; + } + + if (minx != _NOCHANGE) { + if (win->_firstchar[y] > minx || + win->_firstchar[y] == _NOCHANGE) + win->_firstchar[y] = minx; + + if (win->_lastchar[y] < maxx - win->_line[y]) + win->_lastchar[y] = maxx - win->_line[y]; + } + } + win->_curx = win->_cury = 0; + return OK; +} diff --git a/lib/libncurses/lib_getch.c b/lib/libncurses/lib_getch.c new file mode 100644 index 000000000000..47192c2dfef6 --- /dev/null +++ b/lib/libncurses/lib_getch.c @@ -0,0 +1,217 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_getch.c +** +** The routine getch(). +** +*/ + +#include +#include +#include +#include +#ifdef BRAINDEAD +extern int errno; +#endif +#include "curses.priv.h" + +#define head SP->_fifohead +#define tail SP->_fifotail +#define peek SP->_fifopeek + +#define h_inc() { head == FIFO_SIZE-1 ? head = 0 : head++; if (head == tail) head = -1, tail = 0;} +#define h_dec() { head == 0 ? head = FIFO_SIZE-1 : head--; if (head == tail) tail = -1;} +#define t_inc() { tail == FIFO_SIZE-1 ? tail = 0 : tail++; if (tail == head) tail = -1;} +#define p_inc() { peek == FIFO_SIZE-1 ? peek = 0 : peek++;} + +static int fifo_peek() +{ + T(("peeking at %d", peek+1)); + return SP->_fifo[++peek]; +} + +static inline void fifo_dump() +{ +int i; + T(("head = %d, tail = %d, peek = %d", head, tail, peek)); + for (i = 0; i < 10; i++) + T(("char %d = %d (%c)", i, SP->_fifo[i], (unsigned char)SP->_fifo[i])); +} + +static inline int fifo_pull() +{ +int ch; + ch = SP->_fifo[head]; + T(("pulling %d from %d", ch, head)); + + h_inc(); + fifo_dump(); + return ch; +} + +int ungetch(int ch) +{ + if (tail == -1) + return ERR; + if (head == -1) { + head = 0; + t_inc() + } else + h_dec(); + + SP->_fifo[head] = ch; + T(("ungetch ok")); + fifo_dump(); + return OK; +} + +static inline int fifo_push() +{ +int n; +unsigned char ch; + + if (tail == -1) return ERR; +again: + n = read(fileno(SP->_ifp), &ch, 1); + if (n == -1 && errno == EINTR) + goto again; + SP->_fifo[tail] = ch; + if (head == -1) head = tail; + t_inc(); + T(("pushed %d at %d", ch, tail)); + fifo_dump(); + return ch; +} + +static inline void fifo_clear() +{ +int i; + for (i = 0; i < FIFO_SIZE; i++) + SP->_fifo[i] = 0; + head = -1; tail = peek = 0; +} + +static int kgetch(WINDOW *); + +int +wgetch(WINDOW *win) +{ +bool setHere = FALSE; /* cbreak mode was set here */ +int ch; + + T(("wgetch(%x) called", win)); + + /* this should be eliminated */ + if (! win->_scroll && (SP->_echo) && (win->_flags & _FULLWIN) + && win->_curx == win->_maxx && win->_cury == win->_maxy) + return(ERR); + + if ((is_wintouched(win) || (win->_flags & _HASMOVED)) && + !(win->_flags & _ISPAD)) + wrefresh(win); + + if (SP->_echo && ! (SP->_raw || SP->_cbreak)) { + cbreak(); + setHere = TRUE; + } + + if (win->_delay >= 0 || SP->_cbreak > 1) { + int delay; + + T(("timed delay in wgetch()")); + if (SP->_cbreak > 1) + delay = (SP->_cbreak-1) * 100; + else + delay = win->_delay; + + T(("delay is %d microseconds", delay)); + + if (head == -1) /* fifo is empty */ + if (timed_wait(fileno(SP->_ifp), delay, NULL) == 0) + return ERR; + /* else go on to read data available */ + } + + if (win->_use_keypad) + ch = kgetch(win); + else { + fifo_push(); + ch = fifo_pull(); + } + + /* there must be a simpler way of doing this */ + if (!(win->_flags & _ISPAD) && + SP->_echo && ch < 0400) { /* ch < 0400 => not a keypad key */ + mvwaddch(curscr, win->_begy + win->_cury, + win->_begx + win->_curx, ch | win->_attrs); + waddch(win, ch | win->_attrs); + } + if (setHere) + nocbreak(); + + T(("wgetch returning : '%c', '0x%x'", ch, ch)); + + return(ch); +} + + +/* +** int +** kgetch() +** +** Get an input character, but take care of keypad sequences, returning +** an appropriate code when one matches the input. After each character +** is received, set a one-second alarm call. If no more of the sequence +** is received by the time the alarm goes off, pass through the sequence +** gotten so far. +** +*/ + +static int +kgetch(WINDOW *win) +{ +struct try *ptr; +int ch = 0; +int timeleft = 2000; + + T(("kgetch(%x) called", win)); + + ptr = SP->_keytry; + + if (head == -1) { + ch = fifo_push(); + peek = 0; + while (ptr != NULL) { + T(("ch = %d", ch)); + while ((ptr != NULL) && (ptr->ch != (unsigned char)ch)) + ptr = ptr->sibling; + + if (ptr != NULL) + if (ptr->value != 0) { /* sequence terminated */ + T(("end of sequence")); + fifo_clear(); + return(ptr->value); + } else { /* go back for another character */ + ptr = ptr->child; + T(("going back for more")); + } + else + break; + + T(("waiting for rest of sequence")); + if (timed_wait(fileno(SP->_ifp), timeleft, &timeleft) < 1) { + T(("ran out of time")); + return(fifo_pull()); + } else { + T(("got more!")); + fifo_push(); + ch = fifo_peek(); + } + } + } + return(fifo_pull()); +} diff --git a/lib/libncurses/lib_getstr.c b/lib/libncurses/lib_getstr.c new file mode 100644 index 000000000000..fae5b21c1e7e --- /dev/null +++ b/lib/libncurses/lib_getstr.c @@ -0,0 +1,113 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_getstr.c +** +** The routine wgetstr(). +** +*/ + +#include "curses.priv.h" +#include "unctrl.h" + +inline void backspace(WINDOW *win) +{ + mvwaddstr(curscr, win->_begy + win->_cury, win->_begx + win->_curx, + "\b \b"); + waddstr(win, "\b \b"); + fputs("\b \b", SP->_ofp); + fflush(SP->_ofp); + SP->_curscol--; +} + +int wgetnstr(WINDOW *win, char *str, int maxlen) +{ +bool oldnl, oldecho, oldraw, oldcbreak, oldkeypad; +char erasec; +char killc; +char *oldstr; +int ch; + + T(("wgetnstr(%x,%x, %d) called", win, str, maxlen)); + + oldnl = SP->_nl; + oldecho = SP->_echo; + oldraw = SP->_raw; + oldcbreak = SP->_cbreak; + oldkeypad = win->_use_keypad; + nl(); + noecho(); + noraw(); + cbreak(); + keypad(win, FALSE); + + erasec = erasechar(); + killc = killchar(); + + oldstr = str; + + vidattr(win->_attrs); + if (is_wintouched(win) || (win->_flags & _HASMOVED)) + wrefresh(win); + + while ((ch = wgetch(win)) != ERR) { + if (ch == '\n' || ch == '\r') + break; + if (ch == erasec || ch == KEY_LEFT || ch == KEY_BACKSPACE) { + if (str > oldstr) { + str--; + backspace(win); + } + } else if (ch == killc) { + while (str > oldstr) { + str--; + backspace(win); + } + } else if (maxlen >= 0 && str - oldstr >= maxlen) { + beep(); + } else { + mvwaddstr(curscr, win->_begy + win->_cury, + win->_begx + win->_curx, unctrl(ch)); + waddstr(win, unctrl(ch)); + if (oldecho == TRUE) { + fputs(unctrl(ch), SP->_ofp); + fflush(SP->_ofp); + } + SP->_curscol++; + *str++ = ch; + } + } + + win->_curx = 0; + if (win->_cury < win->_maxy) + win->_cury++; + wrefresh(win); + + if (! oldnl) + nonl(); + + if (oldecho) + echo(); + + if (oldraw) + raw(); + + if (! oldcbreak) + nocbreak(); + + if (oldkeypad) + keypad(win, TRUE); + + if (ch == ERR) { + *str = '\0'; + return ERR; + } + *str = '\0'; + + T(("wgetnstr returns %s", oldstr)); + + return(OK); +} diff --git a/lib/libncurses/lib_inchstr.c b/lib/libncurses/lib_inchstr.c new file mode 100644 index 000000000000..d0ad351360f4 --- /dev/null +++ b/lib/libncurses/lib_inchstr.c @@ -0,0 +1,29 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_inchstr.c +** +** The routine winchnstr(). +** +*/ + +#include "curses.priv.h" + +int winchnstr(WINDOW *win, chtype *chstr, int i) +{ +chtype *point, *end; + + T(("winschnstr(%x,'%x',%d) called", win, chstr, i)); + + point = &win->_line[win->_cury][win->_curx]; + end = &win->_line[win->_cury][win->_maxx]; + if (point + i - 1 < end) + end = point + i - 1; + + chstr = (chtype *)malloc((end - point + 1)*sizeof(chtype)); + chstr[end - point] = '\0'; + return OK; +} diff --git a/lib/libncurses/lib_initscr.c b/lib/libncurses/lib_initscr.c new file mode 100644 index 000000000000..a81783fff5c8 --- /dev/null +++ b/lib/libncurses/lib_initscr.c @@ -0,0 +1,32 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_initscr.c +** +** The routine initscr(). +** +*/ + +#include +#include "curses.priv.h" + +WINDOW *initscr() +{ +#ifdef TRACE + _init_trace(); + + if (_tracing) + _tracef("initscr() called"); +#endif + + if (newterm(getenv("TERM"), stdout, stdin) == NULL) + return NULL; + else { + def_shell_mode(); + def_prog_mode(); + return(stdscr); + } +} diff --git a/lib/libncurses/lib_insch.c b/lib/libncurses/lib_insch.c new file mode 100644 index 000000000000..a86732d822dc --- /dev/null +++ b/lib/libncurses/lib_insch.c @@ -0,0 +1,36 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_insch.c +** +** The routine winsch(). +** +*/ + +#include "curses.priv.h" + +int winsch(WINDOW *win, chtype c) +{ +chtype *temp1, *temp2; +chtype *end; + + T(("winsch(%x,'%x') called", win, c)); + + end = &win->_line[win->_cury][win->_curx]; + temp1 = &win->_line[win->_cury][win->_maxx]; + temp2 = temp1 - 1; + + while (temp1 > end) + *temp1-- = *temp2--; + + *temp1 = c | win->_attrs; + + win->_lastchar[win->_cury] = win->_maxx; + if (win->_firstchar[win->_cury] == _NOCHANGE + || win->_firstchar[win->_cury] > win->_curx) + win->_firstchar[win->_cury] = win->_curx; + return OK; +} diff --git a/lib/libncurses/lib_insdel.c b/lib/libncurses/lib_insdel.c new file mode 100644 index 000000000000..df68f8735c77 --- /dev/null +++ b/lib/libncurses/lib_insdel.c @@ -0,0 +1,120 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_insdel.c +** +** The routine winsdel(win, n). +** positive n insert n lines above current line +** negative n delete n lines starting from current line +** +*/ + +#include +#include "curses.priv.h" +#include + +int +winsdel(WINDOW *win, int n) +{ +int line, i; +int touched = 0; +chtype *ptr, *temp; +chtype **saved; +chtype blank = ' '; + + T(("winsdel(%x,%d) called", win, n)); + + if (n == 0) + return OK; + if (n < 0 && win->_cury - n >= win->_maxy) + /* request to delete too many lines */ + /* should we truncate to an appropriate number? */ + return ERR; + + + saved = (chtype **)malloc(sizeof(chtype *) * abs(n)); + + if (n < 0) { + /* save overwritten lines */ + + for (i = 0; i < -n; i++) + saved[i] = win->_line[win->_regbottom-i]; + + /* delete n lines */ + + for (line = win->_regbottom; line >= win->_cury; line--) + win->_line[line] = win->_line[line+n]; + + /* restore saved lines and blank them */ + + for (i = 0, line = win->_regtop; line < win->_regtop-n; line++, i++) { + win->_line[line] = saved[i]; + temp = win->_line[line]; + for (ptr = temp; ptr - temp <= win->_maxx; ptr++) + *ptr = blank; + } + } + + if (n > 0) { + /* save overwritten lines */ + + for (i = 0; i < n; i++) + saved[i] = win->_line[win->_regtop+i]; + + /* insert n lines */ + + for (line = win->_regtop; line < win->_regtop + n; line++) + win->_line[line] = win->_line[line+n]; + + /* restore saved lines and blank them */ + + for (i = 0, line = win->_regtop + n; i < n; line--, i++) { + temp = win->_line[line] = saved[i]; + for (ptr = temp; ptr - temp <= win->_maxx; ptr++) + *ptr = blank; + } + } + + free(saved); + + /* as an optimization, if the window is COLS wide we can try + using idl assuming _idlok is true */ + + if (win->_maxx == columns && win->_idlok == TRUE) { + + if (n > 0) { + mvcur(-1, -1, win->_cury, 0); + if (parm_insert_line) { + putp(tparm(parm_insert_line, n)); + touched = 1; + } else if (insert_line) { + while (n--) + putp(insert_line); + touched = 1; + } + } + + if (n < 0) { + mvcur(-1, -1, win->_cury, 0); + n = abs(n); + if (parm_delete_line) { + putp(tparm(parm_delete_line, n)); + touched = 1; + } else if (delete_line) { + while (n--) + putp(delete_line); + touched = 1; + } + } + + mvcur(-1, -1, win->_cury, win->_curx); + } + if (touched == 0) + touchline(win, win->_regtop, win->_regbottom - win->_regtop + 1); + touched = 0; + + return OK; +} diff --git a/lib/libncurses/lib_insertln.c b/lib/libncurses/lib_insertln.c new file mode 100644 index 000000000000..7a5694e62941 --- /dev/null +++ b/lib/libncurses/lib_insertln.c @@ -0,0 +1,49 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_insertln.c +** +** The routine winsertln(). +** +*/ + +#include "curses.priv.h" +#include + +int winsertln(WINDOW *win) +{ +chtype *temp, *end; +int y, touched = 0; + + T(("winsertln(%x) called", win)); + + temp = win->_line[win->_regbottom]; + + if (win->_idlok && (insert_line != NULL)) { + putp(insert_line); + touched = 1; + } + + if (!touched) { + win->_firstchar[win->_cury] = 0; + win->_lastchar[win->_cury] = win->_maxx; + } + + for (y = win->_regbottom; y > win->_cury; y--) { + win->_line[y] = win->_line[y-1]; + + if (!touched) { + win->_firstchar[y] = 0; + win->_lastchar[y] = win->_maxx; + } + } + + win->_line[win->_cury] = temp; + + for (end = &temp[win->_maxx]; temp <= end; temp++) + *temp = ' ' | win->_attrs; + return OK; +} diff --git a/lib/libncurses/lib_insstr.c b/lib/libncurses/lib_insstr.c new file mode 100644 index 000000000000..63076626d26a --- /dev/null +++ b/lib/libncurses/lib_insstr.c @@ -0,0 +1,21 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_insstr.c +** +** The routine winsnstr(). +** +*/ + +#include "curses.priv.h" + +int winsnstr(WINDOW *win, char *str, int n) +{ + + T(("winsstr(%x,'%x',%d) called", win, str, n)); + + return OK; +} diff --git a/lib/libncurses/lib_kernel.c b/lib/libncurses/lib_kernel.c new file mode 100644 index 000000000000..66659c7b4e24 --- /dev/null +++ b/lib/libncurses/lib_kernel.c @@ -0,0 +1,249 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * lib_kernel.c + * + * Misc. low-level routines: + * wattron() + * reset_prog_mode() + * reset_shell_mode() + * baudrate() + * erasechar() + * killchar() + * flushinp() + * savetty() + * resetty() + * + * + */ + +#include "curses.priv.h" +#include + +int wattron(WINDOW *win, chtype at) +{ + win->_attrs &= (unsigned long)0xffff00ff; + win->_attrs |= at; + return OK; +} + +#ifndef MYTINFO +int reset_prog_mode() +{ + T(("reset_prog_mode() called")); + +#ifdef TERMIOS + tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb); +#else + stty(cur_term->Filedes, &cur_term->Nttyb); +#endif + + return OK; +} + + +int reset_shell_mode() +{ + T(("reset_shell_mode() called")); + +#ifdef TERMIOS + tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Ottyb); +#else + stty(cur_term->Filedes, &cur_term->Ottyb); +#endif + + return OK; +} +#endif + +int curs_set(int vis) +{ + T(("curs_set(%d)", vis)); + + if (vis < 0 || vis > 2) + return ERR; + + switch(vis) { + case 2: + if (cursor_visible) + tputs(cursor_visible, 1, _outc); + break; + case 1: + if (cursor_normal) + tputs(cursor_normal, 1, _outc); + break; + case 0: + if (cursor_invisible) + tputs(cursor_invisible, 1, _outc); + break; + } + return OK; +} + +/* + * erasechar() + * + * Return erase character as given in cur_term->Ottyb. + * + */ + +char +erasechar() +{ + T(("erasechar() called")); + +#ifdef TERMIOS + return(cur_term->Ottyb.c_cc[VERASE]); +#else + return(cur_term->Ottyb.sg_erase); +#endif + +} + + + +/* + * killchar() + * + * Return kill character as given in cur_term->Ottyb. + * + */ + +char +killchar() +{ + T(("killchar() called")); + +#ifdef TERMIOS + return(cur_term->Ottyb.c_cc[VKILL]); +#else + return(cur_term->Ottyb.sg_kill); +#endif +} + + + +/* + * flushinp() + * + * Flush any input on cur_term->Filedes + * + */ + +int flushinp() +{ + T(("flushinp() called")); + +#ifdef TERMIOS + tcflush(cur_term->Filedes, TCIFLUSH); +#else + ioctl(cur_term->Filedes, TIOCFLUSH, 0); +#endif + if (SP) { + SP->_fifohead = -1; + SP->_fifotail = 0; + SP->_fifopeek = 0; + } + return OK; + +} + + + +/* + * int + * baudrate() + * + * Returns the current terminal's baud rate. + * + */ + +struct speed { + speed_t s; + int sp; +}; + +static struct speed speeds[] = { + {B0, 0,}, + {B50, 50,}, + {B75, 75,}, + {B110, 110,}, + {B134, 134,}, + {B150, 150,}, + {B200, 200,}, + {B300, 300,}, + {B600, 600,}, + {B1200, 1200,}, + {B1800, 1800,}, + {B2400, 2400,}, + {B4800, 4800,}, + {B9600, 9600,}, +#define MAX_BAUD B9600 +#ifdef B19200 +#undef MAX_BAUD +#define MAX_BAUD B19200 + {B19200, 19200,}, +#endif +#ifdef B38400 +#undef MAX_BAUD +#define MAX_BAUD B38400 + {B38400, 38000,} +#endif +}; + +int +baudrate() +{ +int i, ret; +#ifdef UNTRACE + if (_tracing) + _tracef("baudrate() called"); +#endif +#ifdef TERMIOS + ret = cfgetospeed(&cur_term->Nttyb); +#else + ret = cur_term->Nttyb.sg_ospeed; +#endif + if(ret < 0 || ret > MAX_BAUD) + return ERR; + for (i = 0; i < (sizeof(speeds) / sizeof(struct speed)); i++) + if (speeds[i].s == ret) + return speeds[i].sp; + return ERR; +} + + +/* +** savetty() and resetty() +** +*/ + +static TTY buf; + +int savetty() +{ + T(("savetty() called")); + +#ifdef TERMIOS + tcgetattr(cur_term->Filedes, &buf); +#else + gtty(cur_term->Filedes, &buf); +#endif + return OK; +} + +int resetty() +{ + T(("resetty() called")); + +#ifdef TERMIOS + tcsetattr(cur_term->Filedes, TCSANOW, &buf); +#else + stty(cur_term->Filedes, &buf); +#endif + return OK; +} + diff --git a/lib/libncurses/lib_longname.c b/lib/libncurses/lib_longname.c new file mode 100644 index 000000000000..528757bd8ae0 --- /dev/null +++ b/lib/libncurses/lib_longname.c @@ -0,0 +1,35 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_longname.c +** +** The routine longname(). +** +*/ + +#include +#include "curses.priv.h" +#include + +char * +longname() +{ +#ifndef MYTINFO +char *ptr; +#endif + + T(("longname() called")); + +#ifdef MYTINFO + return cur_term->name_long; +#else + for (ptr = ttytype + strlen(ttytype); ptr > ttytype; ptr--) + if (*ptr == '|') + return(ptr + 1); + + return(ttytype); +#endif +} diff --git a/lib/libncurses/lib_move.c b/lib/libncurses/lib_move.c new file mode 100644 index 000000000000..e7a28ebb8e4f --- /dev/null +++ b/lib/libncurses/lib_move.c @@ -0,0 +1,33 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_move.c +** +** The routine wmove(). +** +*/ + +#include "curses.priv.h" + +int +wmove(WINDOW *win, int y, int x) +{ +#ifdef TRACE + if (_tracing) + _tracef("wmove(%x,%d,%d) called", win, y, x); +#endif + + if (x >= 0 && x <= win->_maxx && + y >= 0 && y <= win->_maxy) + { + win->_curx = x; + win->_cury = y; + + win->_flags |= _HASMOVED; + return(OK); + } else + return(ERR); +} diff --git a/lib/libncurses/lib_mvcur.c b/lib/libncurses/lib_mvcur.c new file mode 100644 index 000000000000..1a6ba6552118 --- /dev/null +++ b/lib/libncurses/lib_mvcur.c @@ -0,0 +1,719 @@ +/*--------------------------------------------------------------------------- + * + * lib_mvcur.c + * + * The routine mvcur() etc. + * + * last edit-date: [Wed Jun 16 14:13:22 1993] + * + * -hm conversion from termcap -> terminfo + * -hm optimization debugging + * -hm zeyd's ncurses 0.7 update + * -hm eat_newline_glitch bugfix + * -hm hpux lint'ing .. + * + *---------------------------------------------------------------------------*/ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +#include +#include +#include +#include "curses.priv.h" + +#ifndef OPT_MVCUR +/* +** +** mvcur(oldrow, oldcol, newrow, newcol) +** A hack for terminals that are smart enough +** to know how to move cursor. +** There is still a bug in the alternative long- +** winded code. +** +*/ + +int mvcur(int oldrow, int oldcol, int newrow, int newcol) +{ + T(("mvcur(%d,%d,%d,%d) called", oldrow, oldcol, newrow, newcol)); + + if(!cursor_address) + return ERR; + + newrow %= lines; + newcol %= columns; + + if (cursor_address) + putp(tparm(cursor_address, newrow, newcol)); + return OK; + +} + +#else + +#define BUFSIZE 128 /* size of strategy buffer */ + +struct Sequence +{ + int vec[BUFSIZE]; /* vector of operations */ + int *end; /* end of vector */ + int cost; /* cost of vector */ +}; + +static void row(struct Sequence *outseq, int orow, int nrow); +static void column(struct Sequence *outseq, int ocol, int ncol); +static void simp_col(struct Sequence *outseq, int oc, int nc); +static void zero_seq(struct Sequence *seq); +static void add_seq(struct Sequence *seq1, struct Sequence *seq2); +static void out_seq(struct Sequence *seq); +static void update_ops(void); +static void init_costs(int costs[]); +static int countc(char ch); +static void add_op(struct Sequence *seq, int op, ...); +static char *sequence(int op); + +static int c_count; /* used for counting tputs output */ + +#define INFINITY 1000 /* biggest, impossible sequence cost */ +#define NUM_OPS 16 /* num. term. control sequences */ +#define NUM_NPARM 9 /* num. ops wo/ parameters */ + + /* operator indexes into op_info */ + +#define CARRIAGE_RETURN 0 /* watch out for nl mapping */ +#define CURS_DOWN 1 +#define CURS_HOME 2 +#define CURS_LEFT 3 +#define CURS_RIGHT 4 +#define CURS_TO_LL 5 +#define CURS_UP 6 +#define TAB 7 +#define BACK_TAB 8 +#define ROW_ADDR 9 +#define COL_ADDR 10 +#define P_DOWN_CURS 11 +#define P_LEFT_CURS 12 +#define P_RIGHT_CURS 13 +#define P_UP_CURS 14 +#define CURS_ADDR 15 + +static bool loc_init = FALSE; /* set if op_info is init'ed */ + +static bool rel_ok; /* set if we really know where we are */ + +/* + * op_info[NUM_OPS] + * + * op_info[] contains for operations with no parameters + * the cost of the operation. These ops should be first in the array. + * For operations with parameters, op_info[] contains + * the negative of the number of parameters. + */ + +static int op_info[NUM_OPS] = { + 0, /* carriage_return */ + 0, /* cursor_down */ + 0, /* cursor_home */ + 0, /* cursor_left */ + 0, /* cursor_right */ + 0, /* cursor_to_ll */ + 0, /* cursor_up */ + 0, /* tab */ + 0, /* back_tab */ + -1, /* row_address */ + -1, /* column_address */ + -1, /* parm_down_cursor */ + -1, /* parm_left_cursor */ + -1, /* parm_right_cursor */ + -1, /* parm_up_cursor */ + -2 /* cursor_address */ +}; + +/* +** Make_seq_best(best, try) +** +** Make_seq_best() copies try to best if try->cost < best->cost +** +** fixed the old version, now it really runs .. (-hm/08.04.93) +** +*/ + +inline void Make_seq_best(struct Sequence *best, struct Sequence *try) +{ + if (best->cost > try->cost) { + register int *sptr; + + sptr = try->vec; /* src ptr */ + best->end = best->vec; /* dst ptr */ + while(sptr != try->end) /* copy src -> dst */ + *(best->end++) = *(sptr++); + best->cost = try->cost; /* copy cost */ + } +} + + +/* +** +** mvcur(oldrow, oldcol, newrow, newcol) +** +** mvcur() optimally moves the cursor from the position +** specified by (oldrow, oldcol) to (newrow, newcol). If +** (oldrow, oldcol) == (-1, -1), mvcur() does not use relative +** cursor motions. If the coordinates are otherwise +** out of bounds, it mods them into range. +** +** Revisions needed: +** eat_newline_glitch, auto_right_margin +*/ + +int mvcur(int oldrow, int oldcol, int newrow, int newcol) +{ +struct Sequence seqA, seqB, /* allocate work structures */ + col0seq, /* sequence to get from col0 to nc */ + *best, /* best sequence so far */ + *try; /* next try */ +bool nlstat = SP->_nl; /* nl-output-mapping in effect ?*/ + +#ifdef TRACE + if (_tracing) + _tracef("=============================\nmvcur(%d,%d,%d,%d) called", + oldrow, oldcol, newrow, newcol); +#endif + + if ((oldrow == newrow) && (oldcol == newcol)) + return OK; + + if (oldcol == columns-1 && eat_newline_glitch && auto_right_margin) { + tputs(tparm(cursor_address, newrow, newcol), 1, _outc); + return OK; + } + +#if 0 + if (nlstat) + nonl(); +#endif + update_ops(); /* make sure op_info[] is current */ + + if (oldrow < 0 || oldcol < 0 || (eat_newline_glitch && oldcol == 0 )) { + rel_ok = FALSE; /* relative ops ok? */ + } else { + rel_ok = TRUE; + oldrow %= lines; /* mod values into range */ + oldcol %= columns; + } + + newrow %= lines; + newcol %= columns; + + best = &seqA; + try = &seqB; + + /* try out direct cursor addressing */ + + zero_seq(best); + add_op(best, CURS_ADDR, newrow, newcol); + + /* try out independent row/column addressing */ + + if(rel_ok) { + zero_seq(try); + row(try, oldrow, newrow); + column(try, oldcol, newcol); + Make_seq_best(best, try); + } + + zero_seq(&col0seq); /* store seq. to get from c0 to nc */ + column(&col0seq, 0, newcol); + + if(col0seq.cost < INFINITY) { /* can get from col0 to newcol */ + + /* try out homing and then row/column */ + + if (! rel_ok || newcol < oldcol || newrow < oldrow) { + zero_seq(try); + add_op(try, CURS_HOME, 1); + row(try, 0, newrow); + add_seq(try, &col0seq); + Make_seq_best(best, try); + } + + /* try out homing to last line and then row/column */ + + if (! rel_ok || newcol < oldcol || newrow > oldrow) { + zero_seq(try); + add_op(try, CURS_TO_LL, 1); + row(try, lines - 1, newrow); + add_seq(try, &col0seq); + Make_seq_best(best, try); + } + } + + out_seq(best); +#if 0 + if(nlstat) + nl(); +#endif + +#ifdef TRACE + if (_tracing) + _tracef("==================================="); +#endif + + return OK; +} + +/* +** row(outseq, oldrow, newrow) +** +** row() adds the best sequence for moving +** the cursor from oldrow to newrow to seq. +** row() considers row_address, parm_up/down_cursor +** and cursor_up/down. +*/ + +static void +row(struct Sequence *outseq, /* where to put the output */ +int orow, int nrow) /* old, new cursor locations */ +{ +struct Sequence seqA, seqB, + *best, /* best sequence so far */ + *try; /* next try */ + +int parm_cursor, one_step; + + best = &seqA; + try = &seqB; + + if (nrow == orow) + return; + + if (nrow < orow) { + parm_cursor = P_UP_CURS; + one_step = CURS_UP; + } else { + parm_cursor = P_DOWN_CURS; + one_step = CURS_DOWN; + } + + /* try out direct row addressing */ + + zero_seq(best); + add_op(best, ROW_ADDR, nrow); + + /* try out paramaterized up or down motion */ + + if (rel_ok) { + zero_seq(try); + add_op(try, parm_cursor, abs(orow - nrow)); + Make_seq_best(best, try); + } + + /* try getting there one step at a time... */ + + if (rel_ok) { + zero_seq(try); + add_op(try, one_step, abs(orow-nrow)); + Make_seq_best(best, try); + } + + add_seq(outseq, best); +} + + +/* +** column(outseq, oldcol, newcol) +** +** column() adds the best sequence for moving +** the cursor from oldcol to newcol to outseq. +** column() considers column_address, parm_left/right_cursor, +** simp_col(), and carriage_return followed by simp_col(). +*/ + +static void column(struct Sequence *outseq, /* where to put the output */ +int ocol, int ncol) /* old, new cursor column */ +{ +struct Sequence seqA, seqB, + *best, *try; +int parm_cursor; /* set to either parm_up/down_cursor */ + + best = &seqA; + try = &seqB; + + if (ncol == ocol) + return; + + if (ncol < ocol) + parm_cursor = P_LEFT_CURS; + else + parm_cursor = P_RIGHT_CURS; + + /* try out direct column addressing */ + + zero_seq(best); + add_op(best, COL_ADDR, ncol); + + /* try carriage_return then simp_col() */ + + if(! rel_ok || (ncol < ocol)) { + zero_seq(try); + add_op(try, CARRIAGE_RETURN, 1); + simp_col(try, 0, ncol); + Make_seq_best(best, try); + } + if(rel_ok) { + /* try out paramaterized left or right motion */ + + zero_seq(try); + add_op(try, parm_cursor, abs(ocol - ncol)); + Make_seq_best(best, try); + + /* try getting there with simp_col() */ + + zero_seq(try); + simp_col(try, ocol, ncol); + Make_seq_best(best, try); + } + + add_seq(outseq, best); +} + + +/* +** simp_col(outseq, oldcol, newcol) +** +** simp_col() adds the best simple sequence for getting +** from oldcol to newcol to outseq. +** simp_col() considers (back_)tab and cursor_left/right. +** +** Revisions needed: +** Simp_col asssumes that the cost of a (back_)tab +** is less then the cost of one-stepping to get to the same column. +** Should sometimes use overprinting instead of cursor_right. +*/ + +static void +simp_col( struct Sequence *outseq, /* place to put sequence */ +int oc, int nc) /* old column, new column */ +{ +struct Sequence seqA, seqB, tabseq, + *best, *try; +int mytab, tabs, onepast, + one_step, opp_step; + + onepast = -1; + + if (oc == nc) + return; + + if(! rel_ok) { + outseq->cost = INFINITY; + return; + } + + best = &seqA; + try = &seqB; + + if(oc < nc) { + mytab = TAB; + + if (init_tabs > 0 && op_info[TAB] < INFINITY) { + tabs = (nc / init_tabs) - (oc / init_tabs); + onepast = ((nc / init_tabs) + 1) * init_tabs; + if (tabs) + oc = onepast - init_tabs; /* consider it done */ + } else { + tabs = 0; + } + one_step = CURS_RIGHT; + opp_step = CURS_LEFT; + } else { + mytab = BACK_TAB; + if (init_tabs > 0 && op_info[BACK_TAB] < INFINITY) { + tabs = (oc / init_tabs) - (nc / init_tabs); + onepast = ((nc - 1) / init_tabs) * init_tabs; + if (tabs) + oc = onepast + init_tabs; /* consider it done */ + } else { + tabs = 0; + } + one_step = CURS_LEFT; + opp_step = CURS_RIGHT; + } + + /* tab as close as possible to nc */ + + zero_seq(&tabseq); + add_op(&tabseq, mytab, tabs); + + /* try extra tab and backing up */ + + zero_seq(best); + + if (onepast >= 0 && onepast < columns) { + add_op(best, mytab, 1); + add_op(best, opp_step, abs(onepast - nc)); + } else { + best->cost = INFINITY; /* make sure of next swap */ + } + + /* try stepping to nc */ + + zero_seq(try); + add_op(try, one_step, abs(nc - oc)); + Make_seq_best(best, try); + + if (tabseq.cost < INFINITY) + add_seq(outseq, &tabseq); + add_seq(outseq, best); +} + + +/* +** zero_seq(seq) empties seq. +** add_seq(seq1, seq2) adds seq1 to seq2. +** out_seq(seq) outputs a sequence. +*/ + +static void +zero_seq(seq) +struct Sequence *seq; +{ + seq->end = seq->vec; + seq->cost = 0; +} + +static void +add_seq(struct Sequence *seq1, struct Sequence *seq2) +{ +int *vptr; + +#ifdef TRACE + if (_tracing) + _tracef("add_seq(%x, %x)", seq1, seq2); +#endif + + if(seq1->cost >= INFINITY || seq2->cost >= INFINITY) + seq1->cost = INFINITY; + else { + vptr = seq2->vec; + while (vptr != seq2->end) + *(seq1->end++) = *(vptr++); + seq1->cost += seq2->cost; + } +} + + +static void +out_seq(struct Sequence *seq) +{ +int *opptr, prm[9], ps, p, op; +int count; +char *sequence(); + +#ifdef TRACE + if (_tracing) + _tracef("out_seq(%x)", seq); +#endif + + if (seq->cost >= INFINITY) + return; + + for (opptr = seq->vec; opptr < seq->end; opptr++) { + op = *opptr; /* grab operator */ + ps = -op_info[op]; + if(ps > 0) { /* parameterized */ + for (p = 0; p < ps; p++) /* fill in needed parms */ + prm[p] = *(++opptr); + + tputs(tparm(sequence(op), + prm[0], prm[1], prm[2], prm[3], prm[4], + prm[5], prm[6], prm[7], prm[8]), 1, _outc); + } else { + count = *(++opptr); + /*rev should save tputs output instead of mult calls */ + while (count--) /* do count times */ + tputs(sequence(op), 1, _outc); + } + } +} + + +/* +** update_ops() +** +** update_ops() makes sure that +** the op_info[] array is updated and initializes +** the cost array for SP if needed. +*/ + +static void +update_ops() +{ +#ifdef TRACE + if (_tracing) + _tracef("update_ops()"); +#endif + + if (SP) { /* SP structure exists */ + int op; + + if (! SP->_costinit) { /* this term not yet assigned costs */ + loc_init = FALSE; /* if !SP in the future, new term */ + init_costs(SP->_costs); /* fill term costs */ + SP->_costinit = TRUE; + } + + for (op = 0; op < NUM_NPARM; op++) + op_info[op] = SP->_costs[op]; /* set up op_info */ + + /* check for newline that might be mapped... */ + + if (SP->_nlmapping && index(sequence(CURS_DOWN), '\n')) + op_info[CURS_DOWN] = INFINITY; + } else { + if (! loc_init) { /* using local costs */ + loc_init = TRUE; + init_costs(op_info); /* set up op_info */ + } + + /* check for newline that might be mapped... */ + + if (index(sequence(CURS_DOWN), '\n')) + op_info[CURS_DOWN] = INFINITY; + } +} + + +/* +** init_costs(costs) +** +** init_costs() fills the array costs[NUM_NPARM] +** with costs calculated by doing tputs() calls. +*/ + +static void +init_costs(int costs[]) +{ +int i; + + for (i = 0; i < NUM_NPARM; i++) { + if (sequence(i) != (char *) 0) { + c_count = 0; + tputs(sequence(i), 1, countc); + costs[i] = c_count; + } else + costs[i] = INFINITY; + } +} + + +/* +** countc() increments global var c_count. +*/ + +static int countc(char ch) +{ + return(c_count++); +} + +/* +** add_op(seq, op, p0, p1, ... , p8) +** +** add_op() adds the operator op and the appropriate +** number of paramaters to seq. It also increases the +** cost appropriately. +** if op has no parameters, p0 is taken to be a count. +*/ + +static void add_op(struct Sequence *seq, int op, ...) +{ +va_list argp; +int num_ps, p; + +#ifdef TRACE + if (_tracing) + _tracef("adding op %d to sequence", op); +#endif + va_start(argp, op); + + num_ps = - op_info[op]; /* get parms or -cost */ + + *(seq->end++) = op; + + if (num_ps == (- INFINITY) || sequence(op) == (char *) 0) { + seq->cost = INFINITY; + } else if (num_ps <= 0) { /* no parms, -cost */ + int i = va_arg(argp, int); + seq->cost -= i * num_ps; /* ADD count * cost */ + *(seq->end++) = i; + } else { + int prm[9]; + + for (p = 0; p < num_ps; p++) + *(seq->end++) = prm[p] = va_arg(argp, int); + + c_count = 0; + + tputs(tparm(sequence(op), prm[0], prm[1], prm[2], prm[3], prm[4], + prm[5], prm[6], prm[7], prm[8]), 1, countc); + + seq->cost += c_count; + } + va_end(argp); +} + + +/* +** char *sequence(op) +** +** sequence() returns a pointer to the op's +** terminal control sequence. +*/ + +static char *sequence(int op) +{ +#ifdef TRACE + if (_tracing) + _tracef("sequence(%d)", op); +#endif + switch(op) { + case CARRIAGE_RETURN: + return (carriage_return); + case CURS_DOWN: + return (cursor_down); + case CURS_HOME: + return (cursor_home); + case CURS_LEFT: + return (cursor_left); + case CURS_RIGHT: + return (cursor_right); + case CURS_TO_LL: + return (cursor_to_ll); + case CURS_UP: + return (cursor_up); + case TAB: + return (tab); + case BACK_TAB: + return (back_tab); + case ROW_ADDR: + return (row_address); + case COL_ADDR: + return (column_address); + case P_DOWN_CURS: + return (parm_down_cursor); + case P_LEFT_CURS: + return (parm_left_cursor); + case P_RIGHT_CURS: + return (parm_right_cursor); + case P_UP_CURS: + return (parm_up_cursor); + case CURS_ADDR: + return (cursor_address); + default: + return ((char *) 0); + } +} + +#endif + diff --git a/lib/libncurses/lib_mvwin.c b/lib/libncurses/lib_mvwin.c new file mode 100644 index 000000000000..f58925e89d77 --- /dev/null +++ b/lib/libncurses/lib_mvwin.c @@ -0,0 +1,29 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_mvwin.c +** +** The routine mvwin(). +** +*/ + +#include "curses.priv.h" +#include + +int mvwin(WINDOW *win, int by, int bx) +{ + T(("mvwin(%x,%d,%d) called", win, by, bx)); + + if (by + win->_maxy > lines - 1 || bx + win->_maxx > columns - 1) + return(ERR); + + win->_begy = by; + win->_begx = bx; + + touchwin(win); + + return(OK); +} diff --git a/lib/libncurses/lib_newterm.c b/lib/libncurses/lib_newterm.c new file mode 100644 index 000000000000..a411e26f07f5 --- /dev/null +++ b/lib/libncurses/lib_newterm.c @@ -0,0 +1,154 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_newterm.c +** +** The newterm() function. +** +*/ + +#include +#include "curses.priv.h" +#include +#ifdef SVR4_ACTION +#define _POSIX_SOURCE +#endif +#include + +#ifdef MYTINFO +int LINES, COLS; +#endif + +static void cleanup(int sig) +{ + + if (sig == SIGSEGV) + fprintf(stderr, "Got a segmentation violation signal, cleaning up and exiting\n"); + endwin(); + exit(1); +} + +WINDOW *stdscr, *curscr, *newscr; +SCREEN *SP; + +struct ripoff_t +{ + int line; + int (*hook)(); +} +rippedoff[5], *rsp = rippedoff; + +SCREEN * newterm(char *term, FILE *ofp, FILE *ifp) +{ +sigaction_t act; +int errret; +int stolen, topstolen; + +#ifdef TRACE + _init_trace(); + T(("newterm(%s,%x,%x) called", term, ofp, ifp)); +#endif + +#ifdef MYTINFO + if (setupterm(term, fileno(ofp), &errret) != OK) + return NULL; + COLS = cur_term->true_columns; + LINES = cur_term->true_lines; +#else + if (setupterm(term, fileno(ofp), &errret) != 1) + return NULL; +#endif + + if ((SP = (SCREEN *) malloc(sizeof *SP)) == NULL) + return NULL; + + if (ofp == stdout && ifp == stdin) { + SP->_ofp = stdout; + SP->_ifp = stdin; + } else { + SP->_ofp = ofp; + SP->_ifp = ofp; + } + SP->_term = cur_term; + SP->_cursrow = -1; + SP->_curscol = -1; + SP->_keytry = UNINITIALISED; + SP->_nl = TRUE; + SP->_raw = FALSE; + SP->_cbreak = FALSE; + SP->_echo = TRUE; + SP->_nlmapping = TRUE; + SP->_fifohead = -1; + SP->_fifotail = 0; + SP->_fifopeek = 0; + + if (enter_ca_mode) + putp(enter_ca_mode); + + init_acs(); + + T(("creating newscr")); + if ((newscr = newwin(lines, columns, 0, 0)) == (WINDOW *)NULL) + return(NULL); + + T(("creating curscr")); + if ((curscr = newwin(lines, columns, 0, 0)) == (WINDOW *)NULL) + return(NULL); + + SP->_newscr = newscr; + SP->_curscr = curscr; + + newscr->_clear = TRUE; + curscr->_clear = FALSE; + + stolen = topstolen = 0; + for (rsp = rippedoff; rsp->line; rsp++) + { + if (rsp->hook) + if (rsp->line < 0) + rsp->hook(newwin(1,COLS, LINES-1,0), COLS); + else + rsp->hook(newwin(1,COLS, topstolen++,0), COLS); + --LINES; + stolen++; + } + + act.sa_handler = tstp; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; + sigaction(SIGTSTP, &act, NULL); + act.sa_handler = cleanup; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; + sigaction(SIGINT, &act, NULL); +#if 0 + sigaction(SIGSEGV, &act, NULL); +#endif + if (stdscr == NULL) + if ((stdscr = newwin(lines - stolen, columns, topstolen, 0)) == NULL) + return(NULL); + + T(("newterm returns %x", SP)); + + return(SP); +} + +int +ripoffline(int line, int (*init)(WINDOW *, int)) +{ + if (line == 0) + return(OK); + + if (rsp >= rippedoff + sizeof(rippedoff)/sizeof(rippedoff[0])) + return(ERR); + + rsp->line = line; + rsp->hook = init; + rsp++; + + return(OK); +} + diff --git a/lib/libncurses/lib_newwin.c b/lib/libncurses/lib_newwin.c new file mode 100644 index 000000000000..f732a7c73baf --- /dev/null +++ b/lib/libncurses/lib_newwin.c @@ -0,0 +1,177 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_newwin.c +** +** The routines newwin(), subwin() and their dependent +** +*/ + +#include +#include +#include "curses.priv.h" + +WINDOW * newwin(int num_lines, int num_columns, int begy, int begx) +{ +WINDOW *win; +chtype *ptr; +int i, j; + + T(("newwin(%d,%d,%d,%d) called", num_lines, num_columns, begy, begx)); + + if (num_lines == 0) + num_lines = lines - begy; + + if (num_columns == 0) + num_columns = columns - begx; + + if (num_columns + begx > columns || num_lines + begy > lines) + return NULL; + + if ((win = makenew(num_lines, num_columns, begy, begx)) == NULL) + return NULL; + + for (i = 0; i < num_lines; i++) { + if ((win->_line[i] = (chtype *) calloc(num_columns, sizeof(chtype))) == NULL) { + for (j = 0; j < i; j++) + free(win->_line[j]); + + free(win->_firstchar); + free(win->_lastchar); + free(win->_line); + free(win); + + return NULL; + } + else + for (ptr = win->_line[i]; ptr < win->_line[i] + num_columns; ) + *ptr++ = ' '; + } + + T(("newwin: returned window is %x", win)); + + return(win); +} + +WINDOW * derwin(WINDOW *orig, int num_lines, int num_columns, int begy, int begx) +{ +WINDOW *win; +int i; + + T(("derwin(%x, %d,%d,%d,%d) called", orig, num_lines, num_columns, begy, begx)); + + /* + ** make sure window fits inside the original one + */ + if ( begy < 0 || begx < 0) + return NULL; + if ( begy + num_lines > orig->_maxy + 1 + || begx + num_columns > orig->_maxx + 1) + return NULL; + + if (num_lines == 0) + num_lines = orig->_maxy - orig->_begy - begy; + + if (num_columns == 0) + num_columns = orig->_maxx - orig->_begx - begx; + + if ((win = makenew(num_lines, num_columns, orig->_begy + begy, orig->_begx + begx)) == NULL) + return NULL; + + win->_pary = begy; + win->_parx = begx; + + for (i = 0; i < num_lines; i++) + win->_line[i] = &orig->_line[begy++][begx]; + + win->_flags = _SUBWIN; + win->_parent = orig; + + T(("derwin: returned window is %x", win)); + + return(win); +} + + +WINDOW *subwin(WINDOW *w, int l, int c, int y, int x) +{ + T(("subwin(%x, %d, %d, %d, %d) called", w, l, c, y, x)); + T(("parent has begy = %d, begx = %d", w->_begy, w->_begx)); + + return derwin(w, l, c, y - w->_begy, x - w->_begx); +} + +WINDOW * +makenew(int num_lines, int num_columns, int begy, int begx) +{ +int i; +WINDOW *win; + + T(("makenew(%d,%d,%d,%d)", num_lines, num_columns, begy, begx)); + + if ((win = (WINDOW *) malloc(sizeof(WINDOW))) == NULL) + return NULL; + + if ((win->_line = (chtype **) calloc(num_lines, sizeof (chtype *))) == NULL) { + free(win); + return NULL; + } + + if ((win->_firstchar = calloc(num_lines, sizeof(short))) == NULL) { + free(win); + free(win->_line); + return NULL; + } + + if ((win->_lastchar = calloc(num_lines, sizeof(short))) == NULL) { + free(win); + free(win->_line); + free(win->_firstchar); + return NULL; + } + + win->_curx = 0; + win->_cury = 0; + win->_maxy = num_lines - 1; + win->_maxx = num_columns - 1; + win->_begy = begy; + win->_begx = begx; + + win->_flags = 0; + win->_attrs = A_NORMAL; + + win->_clear = (num_lines == lines && num_columns == columns); + win->_idlok = FALSE; + win->_use_idc = TRUE; + win->_scroll = FALSE; + win->_leave = FALSE; + win->_use_keypad = FALSE; + win->_use_meta = FALSE; + win->_delay = -1; + win->_immed = FALSE; + win->_sync = 0; + win->_parx = 0; + win->_pary = 0; + win->_parent = (WINDOW *)NULL; + + win->_regtop = 0; + win->_regbottom = num_lines - 1; + + for (i = 0; i < num_lines; i++) + win->_firstchar[i] = win->_lastchar[i] = _NOCHANGE; + + if (begx + num_columns == columns) { + win->_flags |= _ENDLINE; + + if (begx == 0 && num_lines == lines && begy == 0) + win->_flags |= _FULLWIN; + + if (begy + num_lines == lines) + win->_flags |= _SCROLLWIN; + } + + return(win); +} diff --git a/lib/libncurses/lib_options.c b/lib/libncurses/lib_options.c new file mode 100644 index 000000000000..fa4cbf0d9814 --- /dev/null +++ b/lib/libncurses/lib_options.c @@ -0,0 +1,229 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_options.c +** +** The routines to handle option setting. +** +*/ + +#include +#include +#include "curses.priv.h" + +int idlok(WINDOW *win, int flag) +{ + T(("idlok(%x,%d) called", win, flag)); + + if (insert_line || delete_line || parm_insert_line || parm_delete_line) { + win->_idlok = flag; + } + return OK; +} + + +int clearok(WINDOW *win, int flag) +{ + T(("clearok(%x,%d) called", win, flag)); + + if (win == curscr) + newscr->_clear = flag; + else + win->_clear = flag; + return OK; +} + + +int leaveok(WINDOW *win, int flag) +{ + T(("leaveok(%x,%d) called", win, flag)); + + win->_leave = flag; + return OK; +} + + +int scrollok(WINDOW *win, int flag) +{ + T(("scrollok(%x,%d) called", win, flag)); + + win->_scroll = flag; + return OK; +} + +int halfdelay(int t) +{ + T(("halfdelay(%d) called", t)); + + if (t < 1 || t > 255) + return ERR; + + cbreak(); + SP->_cbreak = t+1; + return OK; +} + +int nodelay(WINDOW *win, int flag) +{ + T(("nodelay(%x,%d) called", win, flag)); + + if (flag == TRUE) + win->_delay = 0; + else win->_delay = -1; + return OK; +} + +int notimeout(WINDOW *win, bool f) +{ + T(("notimout(%x,%d) called", win, f)); + + win->_notimeout = f; + return OK; +} + +int wtimeout(WINDOW *win, int delay) +{ + T(("wtimeout(%x,%d) called", win, delay)); + + win->_delay = delay; + return OK; +} + +static void init_keytry(); +static void add_to_try(char *, short); + +int keypad(WINDOW *win, int flag) +{ + T(("keypad(%x,%d) called", win, flag)); + + win->_use_keypad = flag; + + if (flag && keypad_xmit) + tputs(keypad_xmit, 1, _outc); + else if (! flag && keypad_local) + tputs(keypad_local, 1, _outc); + + if (SP->_keytry == UNINITIALISED) + init_keytry(); + return OK; +} + + + +int meta(WINDOW *win, int flag) +{ + T(("meta(%x,%d) called", win, flag)); + + win->_use_meta = flag; + + if (flag && meta_on) + tputs(meta_on, 1, _outc); + else if (! flag && meta_off) + tputs(meta_off, 1, _outc); + return OK; +} + +/* +** init_keytry() +** +** Construct the try for the current terminal's keypad keys. +** +*/ + + +static struct try *newtry; + +static void init_keytry() +{ + newtry = NULL; + +#include "keys.tries" + + SP->_keytry = newtry; +} + + +static void add_to_try(char *str, short code) +{ +static bool out_of_memory = FALSE; +struct try *ptr, *savedptr; + + if (! str || out_of_memory) + return; + + if (newtry != NULL) { + ptr = savedptr = newtry; + + for (;;) { + while (ptr->ch != (unsigned char) *str + && ptr->sibling != NULL) + ptr = ptr->sibling; + + if (ptr->ch == (unsigned char) *str) { + if (*(++str)) { + if (ptr->child != NULL) + ptr = ptr->child; + else + break; + } else { + ptr->value = code; + return; + } + } else { + if ((ptr->sibling = (struct try *) malloc(sizeof *ptr)) == NULL) { + out_of_memory = TRUE; + return; + } + + savedptr = ptr = ptr->sibling; + ptr->child = ptr->sibling = NULL; + ptr->ch = *str++; + ptr->value = (short) NULL; + + break; + } + } /* end for (;;) */ + } else { /* newtry == NULL :: First sequence to be added */ + savedptr = ptr = newtry = (struct try *) malloc(sizeof *ptr); + + if (ptr == NULL) { + out_of_memory = TRUE; + return; + } + + ptr->child = ptr->sibling = NULL; + ptr->ch = *(str++); + ptr->value = (short) NULL; + } + + /* at this point, we are adding to the try. ptr->child == NULL */ + + while (*str) { + ptr->child = (struct try *) malloc(sizeof *ptr); + + ptr = ptr->child; + + if (ptr == NULL) { + out_of_memory = TRUE; + + ptr = savedptr; + while (ptr != NULL) { + savedptr = ptr->child; + free(ptr); + ptr = savedptr; + } + + return; + } + + ptr->child = ptr->sibling = NULL; + ptr->ch = *(str++); + ptr->value = (short) NULL; + } + + ptr->value = code; + return; +} diff --git a/lib/libncurses/lib_overlay.c b/lib/libncurses/lib_overlay.c new file mode 100644 index 000000000000..62bb2f162c90 --- /dev/null +++ b/lib/libncurses/lib_overlay.c @@ -0,0 +1,110 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_overlay.c +** +** The routines overlay(), copywin(), and overwrite(). +** +*/ + +#include "curses.priv.h" + +static void overlap(WINDOW *s, WINDOW *d, int flag) +{ +int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol; + + T(("overlap : sby %d, sbx %d, smy %d, smx %d, dby %d, dbx %d, dmy %d, dmx %d", + s->_begy, s->_begx, s->_maxy, s->_maxx, + d->_begy, d->_begx, d->_maxy, d->_maxx)); + sminrow = max(s->_begy, d->_begy) - s->_begy; + smincol = max(s->_begx, d->_begx) - s->_begx; + dminrow = max(s->_begy, d->_begy) - d->_begy; + dmincol = max(s->_begx, d->_begx) - d->_begx; + dmaxrow = min(s->_maxy+s->_begy, d->_maxy+d->_begy) - d->_begy; + dmaxcol = min(s->_maxx+s->_begx, d->_maxx+d->_begx) - d->_begx; + + copywin(s, d, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol, flag); +} + +/* +** +** overlay(win1, win2) +** +** +** overlay() writes the overlapping area of win1 behind win2 +** on win2 non-destructively. +** +**/ + +int overlay(WINDOW *win1, WINDOW *win2) +{ + overlap(win1, win2, TRUE); + return OK; +} + +/* +** +** overwrite(win1, win2) +** +** +** overwrite() writes the overlapping area of win1 behind win2 +** on win2 destructively. +** +**/ + +int overwrite(WINDOW *win1, WINDOW *win2) +{ + overlap(win1, win2, FALSE); + return OK; +} + +int copywin(WINDOW *src, WINDOW *dst, + int sminrow, int smincol, + int dminrow, int dmincol, int dmaxrow, int dmaxcol, + int over) +{ +int sx, sy, dx, dy; + + T(("copywin(%x, %x, %d, %d, %d, %d, %d, %d, %d)", + src, dst, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol, over)); + + /* make sure rectangle exists in source */ + if ((sminrow + dmaxrow - dminrow) > (src->_maxy + 1) || + (smincol + dmaxcol - dmincol) > (src->_maxx + 1)) { + return ERR; + } + + T(("rectangle exists in source")); + + /* make sure rectangle fits in destination */ + if (dmaxrow > dst->_maxy || dmaxcol > dst->_maxx) { + return ERR; + } + + T(("rectangle fits in destination")); + + for (dy = dminrow, sy = sminrow; dy <= dmaxrow; sy++, dy++) { + dst->_firstchar[dy] = dmincol; + dst->_lastchar[dy] = dmincol; + for (dx = dmincol, sx = smincol; dx <= dmaxcol; sx++, dx++) { + if (over == TRUE ) { + if (((src->_line[sy][sx] & A_CHARTEXT) != ' ') && (dst->_line[dy][dx] != src->_line[sy][sx])) { + dst->_line[dy][dx] = src->_line[sy][sx]; + dst->_lastchar[dy] = dx; + } else + dst->_firstchar[dy]++; + } else { + if (dst->_line[dy][dx] != src->_line[sy][sx]) { + dst->_line[dy][dx] = src->_line[sy][sx]; + dst->_lastchar[dy] = dx; + } else + dst->_firstchar[dy]++; + } + } + } + T(("finished copywin")); + return OK; +} diff --git a/lib/libncurses/lib_pad.c b/lib/libncurses/lib_pad.c new file mode 100644 index 000000000000..75a639c84124 --- /dev/null +++ b/lib/libncurses/lib_pad.c @@ -0,0 +1,142 @@ +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * lib_pad.c + * newpad -- create a new pad + * pnoutrefresh -- refresh a pad, no update + * pechochar -- add a char to a pad and refresh + */ + +#include +#include "curses.priv.h" + +WINDOW *newpad(int l, int c) +{ +WINDOW *win; +chtype *ptr; +int i, j; + + T(("newpad(%d, %d) called", l, c)); + + if (l <= 0 || c <= 0) + return NULL; + + if ((win = makenew(l,c,0,0)) == NULL) + return NULL; + + win->_flags |= _ISPAD; + + for (i = 0; i < l; i++) { + if ((win->_line[i] = (chtype *) calloc(c, sizeof(chtype))) == NULL) { + for (j = 0; j < i; j++) + free(win->_line[j]); + + free(win->_firstchar); + free(win->_lastchar); + free(win->_line); + free(win); + + return NULL; + } + else + for (ptr = win->_line[i]; ptr < win->_line[i] + c; ) + *ptr++ = ' '; + } + + T(("newpad: returned window is %x", win)); + + return(win); +} + +int prefresh(WINDOW *win, int pminrow, int pmincol, + int sminrow, int smincol, int smaxrow, int smaxcol) +{ + T(("prefresh() called")); + if (pnoutrefresh(win, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol) != ERR) + return (doupdate()); + else + return ERR; + +} + +int pnoutrefresh(WINDOW *win, int pminrow, int pmincol, + int sminrow, int smincol, int smaxrow, int smaxcol) +{ +int i, j; +int m, n; + + T(("pnoutrefresh(%x, %d, %d, %d, %d, %d, %d) called", + win, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol)); + + if (!(win->_flags & _ISPAD)) + return ERR; + + T(("one")); + if (pminrow < 0) pminrow = 0; + if (pmincol < 0) pmincol = 0; + if (sminrow < 0) sminrow = 0; + if (smincol < 0) smincol = 0; + + T(("two")); + if (smaxrow >= LINES || smaxcol >= COLS) + return ERR; + + T(("three")); + if ((pminrow + smaxrow > win->_maxy) || (pmincol + smaxcol > win->_maxx)) + return ERR; + + T(("pad being refreshed")); + + for (i = pminrow, m = sminrow; i <= smaxrow + pminrow; i++, m++) { + j = pmincol; + n = j + smincol; + for (; j <= pmincol + smaxcol; j++, n++) { + if (win->_line[i][j] != newscr->_line[m][n]) { + newscr->_line[m][n] = win->_line[i][j]; + + if (newscr->_firstchar[m] == _NOCHANGE) + newscr->_firstchar[m] = newscr->_lastchar[m] = n; + else if (n < newscr->_firstchar[m]) + newscr->_firstchar[m] = n; + else if (n > newscr->_lastchar[m]) + newscr->_lastchar[m] = n; + } + } + } + + win->_firstchar[i] = win->_lastchar[i] = _NOCHANGE; + + win->_begx = smincol; + win->_begy = sminrow; + + if (win->_clear) { + win->_clear = FALSE; + newscr->_clear = TRUE; + } + + if (! win->_leave) { + newscr->_cury = win->_cury + win->_begy; + newscr->_curx = win->_curx + win->_begx; + } + return OK; +} + +int pechochar(WINDOW *pad, chtype ch) +{ +int x, y; + + T(("echochar(%x, %x)", pad, ch)); + + if (pad->_flags & _ISPAD) + return ERR; + + x = pad->_begx + pad->_curx; + y = pad->_begy + pad->_cury; + + waddch(curscr, ch); + doupdate(); + return OK; +} + diff --git a/lib/libncurses/lib_printw.c b/lib/libncurses/lib_printw.c new file mode 100644 index 000000000000..f4609c3a552e --- /dev/null +++ b/lib/libncurses/lib_printw.c @@ -0,0 +1,81 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_printw.c +** +** The routines printw(), wprintw() and friends. +** +*/ + +#include "curses.priv.h" + +int printw(char *fmt, ...) +{ +va_list argp; +char buf[BUFSIZ]; + +#ifdef TRACE + if (_tracing) + _tracef("printw(%s,...) called", fmt); +#endif + + va_start(argp, fmt); + vsprintf(buf, fmt, argp); + va_end(argp); + return(waddstr(stdscr, buf)); +} + + + +int wprintw(WINDOW *win, char *fmt, ...) +{ +va_list argp; +char buf[BUFSIZ]; + +#ifdef TRACE + if (_tracing) + _tracef("wprintw(%x,%s,...) called", win, fmt); +#endif + + va_start(argp, fmt); + vsprintf(buf, fmt, argp); + va_end(argp); + return(waddstr(win, buf)); +} + + + +int mvprintw(int y, int x, char *fmt, ...) +{ +va_list argp; +char buf[BUFSIZ]; + + va_start(argp, fmt); + vsprintf(buf, fmt, argp); + va_end(argp); + return(move(y, x) == OK ? waddstr(stdscr, buf) : ERR); +} + + + +int mvwprintw(WINDOW *win, int y, int x, char *fmt, ...) +{ +va_list argp; +char buf[BUFSIZ]; + + va_start(argp, fmt); + vsprintf(buf, fmt, argp); + va_end(argp); + return(wmove(win, y, x) == OK ? waddstr(win, buf) : ERR); +} + +int vwprintw(WINDOW *win, char *fmt, va_list argp) +{ +char buf[BUFSIZ]; + + vsprintf(buf, fmt, argp); + return(waddstr(win, buf)); +} diff --git a/lib/libncurses/lib_raw.c b/lib/libncurses/lib_raw.c new file mode 100644 index 000000000000..fb2b928f3bd5 --- /dev/null +++ b/lib/libncurses/lib_raw.c @@ -0,0 +1,195 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * raw.c + * + * Routines: + * raw() + * echo() + * nl() + * cbreak() + * noraw() + * noecho() + * nonl() + * nocbreak() + * + */ + +#include "curses.priv.h" +#include + +int raw() +{ + T(("raw() called")); + + SP->_raw = TRUE; + SP->_cbreak = TRUE; + SP->_nlmapping = TRUE; + +#ifdef TERMIOS + cur_term->Nttyb.c_lflag &= ~(ICANON|ISIG); + cur_term->Nttyb.c_iflag &= ~(INPCK|ISTRIP|IXON); + cur_term->Nttyb.c_oflag &= ~(OPOST); + cur_term->Nttyb.c_cc[VMIN] = 1; + cur_term->Nttyb.c_cc[VTIME] = 0; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags |= RAW; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} + +int cbreak() +{ + T(("cbreak() called")); + + SP->_cbreak = 1; + +#ifdef TERMIOS + cur_term->Nttyb.c_lflag &= ~ICANON; + cur_term->Nttyb.c_lflag |= ISIG; + cur_term->Nttyb.c_cc[VMIN] = 1; + cur_term->Nttyb.c_cc[VTIME] = 0; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags |= CBREAK; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} + +int echo() +{ + T(("echo() called")); + + SP->_echo = TRUE; + +#ifdef TERMIOS + cur_term->Nttyb.c_lflag |= ECHO; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags |= ECHO; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} + + +int nl() +{ + T(("nl() called")); + + SP->_nl = TRUE; + SP->_nlmapping = ! SP->_raw; + +#ifdef TERMIOS + cur_term->Nttyb.c_iflag |= IXON|ICRNL|IXOFF; + cur_term->Nttyb.c_oflag |= OPOST|ONLCR; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags |= CRMOD; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} + + +int noraw() +{ + T(("noraw() called")); + + SP->_raw = FALSE; + SP->_cbreak = FALSE; + SP->_nlmapping = SP->_nl; + +#ifdef TERMIOS + cur_term->Nttyb.c_lflag |= ISIG|ICANON; + cur_term->Nttyb.c_iflag |= IXON; + cur_term->Nttyb.c_oflag |= OPOST; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags &= ~(RAW|CBREAK); + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif + +} + + +int nocbreak() +{ + T(("nocbreak() called")); + + SP->_cbreak = 0; + +#ifdef TERMIOS + cur_term->Nttyb.c_lflag |= ICANON; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags &= ~CBREAK; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} + +int noecho() +{ + T(("noecho() called")); + + SP->_echo = FALSE; + +#ifdef TERMIOS + cur_term->Nttyb.c_lflag &= ~(ECHO); + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags &= ~ECHO; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} + + +int nonl() +{ + T(("nonl() called")); + + SP->_nl = SP->_nlmapping = FALSE; + +#ifdef TERMIOS + cur_term->Nttyb.c_iflag &= ~ICRNL; + cur_term->Nttyb.c_oflag &= ~ONLCR; + if((tcsetattr(cur_term->Filedes, TCSANOW, &cur_term->Nttyb)) == -1) + return ERR; + else + return OK; +#else + cur_term->Nttyb.sg_flags &= ~CRMOD; + stty(cur_term->Filedes, &cur_term->Nttyb); + return OK; +#endif +} diff --git a/lib/libncurses/lib_refresh.c b/lib/libncurses/lib_refresh.c new file mode 100644 index 000000000000..72ab095d15b7 --- /dev/null +++ b/lib/libncurses/lib_refresh.c @@ -0,0 +1,74 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * lib_refresh.c + * + * The routines wredrawln(), wrefresh() and wnoutrefresh(). + * + */ + +#include "curses.priv.h" + +int wredrawln(WINDOW *win, int beg, int num) +{ + T(("wredrawln(%x,%d,%d) called", win, beg, num)); + touchline(win, beg, num); + wrefresh(win); + return OK; +} + +int wrefresh(WINDOW *win) +{ + T(("wrefresh(%x) called", win)); + + if (win == curscr) + curscr->_clear = TRUE; + else + wnoutrefresh(win); + return(doupdate()); +} + +int wnoutrefresh(WINDOW *win) +{ +int i, j; +int begx = win->_begx; +int begy = win->_begy; +int m, n; + + T(("wnoutrefresh(%x) called", win)); + + win->_flags &= ~_HASMOVED; + for (i = 0, m = begy; i <= win->_maxy; i++, m++) { + if (win->_firstchar[i] != _NOCHANGE) { + j = win->_firstchar[i]; + n = j + begx; + for (; j <= win->_lastchar[i]; j++, n++) { + if (win->_line[i][j] != newscr->_line[m][n]) { + newscr->_line[m][n] = win->_line[i][j]; + + if (newscr->_firstchar[m] == _NOCHANGE) + newscr->_firstchar[m] = newscr->_lastchar[m] = n; + else if (n < newscr->_firstchar[m]) + newscr->_firstchar[m] = n; + else if (n > newscr->_lastchar[m]) + newscr->_lastchar[m] = n; + } + } + } + win->_firstchar[i] = win->_lastchar[i] = _NOCHANGE; + } + + if (win->_clear) { + win->_clear = FALSE; + newscr->_clear = TRUE; + } + + if (! win->_leave) { + newscr->_cury = win->_cury + win->_begy; + newscr->_curx = win->_curx + win->_begx; + } + return(OK); +} diff --git a/lib/libncurses/lib_scanw.c b/lib/libncurses/lib_scanw.c new file mode 100644 index 000000000000..68aeaeae3ffd --- /dev/null +++ b/lib/libncurses/lib_scanw.c @@ -0,0 +1,72 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_scanw.c +** +** The routines scanw(), wscanw() and friends. +** +*/ + +#include "curses.priv.h" + +int vwscanw(WINDOW *win, char *fmt, va_list argp) +{ +char buf[BUFSIZ]; + + if (wgetstr(win, buf) == ERR) + return(ERR); + + return(vsscanf(buf, fmt, argp)); +} + +int scanw(char *fmt, ...) +{ +va_list ap; + +#ifdef TRACE + if (_tracing) + _tracef("scanw(%s,...) called", fmt); +#endif + + va_start(ap, fmt); + return(vwscanw(stdscr, fmt, ap)); +} + +int wscanw(WINDOW *win, char *fmt, ...) +{ +va_list ap; + +#ifdef TRACE + if (_tracing) + _tracef("wscanw(%x,%s,...) called", win, fmt); +#endif + + va_start(ap, fmt); + return(vwscanw(win, fmt, ap)); +} + + + +int mvscanw(int y, int x, char *fmt, ...) +{ +va_list ap; + + va_start(ap, fmt); + return(move(y, x) == OK ? vwscanw(stdscr, fmt, ap) : ERR); +} + + + +int mvwscanw(WINDOW *win, int y, int x, char *fmt, ...) +{ +va_list ap; + + va_start(ap, fmt); + return(wmove(win, y, x) == OK ? vwscanw(win, fmt, ap) : ERR); +} + + + diff --git a/lib/libncurses/lib_screen.c b/lib/libncurses/lib_screen.c new file mode 100644 index 000000000000..0c0ab8ac5d7f --- /dev/null +++ b/lib/libncurses/lib_screen.c @@ -0,0 +1,58 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +#included "curses.priv.h" + +int putwin(WINDOW *win, char *file) +{ +int fd, i; + + fd = open(file, O_WRONLY); + if (fd < -1) + return ERR; + for (i = 0; i < lines; i++) + write(fd, win->_line[i], sizeof(chtype)*columns); + close(fd); + return OK; +} + +int scr_restore(char *file) +{ +int fd, i; + + fd = open(file, O_RDONLY); + if (fd < -1) + return ERR; + for (i = 0; i < lines; i++) + read(fd, curscr->_line[i], sizeof(chtype)*columns); + touchwin(curscr); + close(fd); + return OK; +} + +int scr_dump(char *file) +{ + + putwin(curscr, file); +} + +int scr_init(char *file) +{ + + return ERR; +} + +int scr_set(char *file) +{ + + return ERR; +} + +WINDOW *getwin(FILE *filep) +{ + + return NULL; +} + diff --git a/lib/libncurses/lib_scroll.c b/lib/libncurses/lib_scroll.c new file mode 100644 index 000000000000..a1f2a098f914 --- /dev/null +++ b/lib/libncurses/lib_scroll.c @@ -0,0 +1,120 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_scroll.c +** +** The routine wscrl(win, n). +** positive n scroll the window up (ie. move lines down) +** negative n scroll the window down (ie. move lines up) +** +*/ + +#include +#include "curses.priv.h" +#include + +int +wscrl(WINDOW *win, int n) +{ +int line, i; +chtype *ptr, *temp; +chtype **saved; +chtype blank = ' '; + + T(("wscrl(%x,%d) called", win, n)); + + if (! win->_scroll) + return ERR; + + if (n == 0) + return OK; + + /* test for scrolling region == entire screen */ + + saved = (chtype **)malloc(sizeof(chtype *) * abs(n)); + + if (n < 0) { + /* save overwritten lines */ + + for (i = 0; i < -n; i++) + saved[i] = win->_line[win->_regbottom-i]; + + /* shift n lines */ + + for (line = win->_regbottom; line > win->_regtop+n; line--) + win->_line[line] = win->_line[line+n]; + + /* restore saved lines and blank them */ + + for (i = 0, line = win->_regtop; line < win->_regtop-n; line++, i++) { + win->_line[line] = saved[i]; + temp = win->_line[line]; + for (ptr = temp; ptr - temp <= win->_maxx; ptr++) + *ptr = blank; + } + } + + if (n > 0) { + /* save overwritten lines */ + + for (i = 0; i < n; i++) + saved[i] = win->_line[win->_regtop+i]; + + /* shift n lines */ + + for (line = win->_regtop; line < win->_regbottom; line++) + win->_line[line] = win->_line[line+n]; + + /* restore saved lines and blank them */ + + for (i = 0, line = win->_regbottom; line > win->_regbottom - n; line--, i++) { + win->_line[line] = saved[i]; + temp = win->_line[line]; + for (ptr = temp; ptr - temp <= win->_maxx; ptr++) + *ptr = blank; + } + } + + free(saved); + + /* as an optimization, if the scrolling region is the entire screen + scroll the physical screen */ + /* should we extend this to include smaller scrolling ranges by using + change_scroll_region? */ + + if (win->_maxx == columns && win->_regtop == 0 && win->_regbottom == lines) { + + /* at the moment this relies on scroll_reverse and scroll_forward + or parm_rindex and parm_index. + we should add idl support as an alternative */ + + if (n > 0) { + mvcur(-1, -1, win->_regtop, 0); + if (parm_rindex) { + putp(tparm(parm_rindex, n)); + } else if (scroll_reverse) { + while (n--) + putp(scroll_reverse); + } + } + + if (n < 0) { + mvcur(-1, -1, win->_regbottom, columns); + n = abs(n); + if (parm_index) { + putp(tparm(parm_index, n)); + } else if (scroll_forward) { + while (n--) + putp(scroll_forward); + } + } + + mvcur(-1, -1, win->_cury, win->_curx); + } else + touchline(win, win->_regtop, win->_regbottom - win->_regtop + 1); + + return OK; +} diff --git a/lib/libncurses/lib_scrreg.c b/lib/libncurses/lib_scrreg.c new file mode 100644 index 000000000000..d8c142327ee3 --- /dev/null +++ b/lib/libncurses/lib_scrreg.c @@ -0,0 +1,32 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_scrreg.c +** +** The routine wsetscrreg(). +** +*/ + +#include "curses.priv.h" + +int wsetscrreg(WINDOW *win, int top, int bottom) +{ + T(("wsetscrreg(%x,%d,%d) called", win, top, bottom)); + + if (top >= 0 && top <= win->_maxy && + bottom >= 0 && bottom <= win->_maxy && + bottom > top) + { + win->_regtop = top; + win->_regbottom = bottom; + + T(("correctly set scrolling region between %d and %d", top, bottom)); + + return(OK); + } + else + return(ERR); +} diff --git a/lib/libncurses/lib_set_term.c b/lib/libncurses/lib_set_term.c new file mode 100644 index 000000000000..7f273a8f47d7 --- /dev/null +++ b/lib/libncurses/lib_set_term.c @@ -0,0 +1,35 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_set_term.c +** +** The routine set_term(). +** +*/ + +#include "curses.priv.h" +#include + +struct screen * +set_term(screen) +struct screen *screen; +{ +struct screen *oldSP; + +#ifdef TRACE + if (_tracing) + _tracef("set_term(%o) called", screen); +#endif + + oldSP = SP; + SP = screen; + + cur_term = SP->_term; + curscr = SP->_curscr; + newscr = SP->_newscr; + + return(oldSP); +} diff --git a/lib/libncurses/lib_slk.c b/lib/libncurses/lib_slk.c new file mode 100644 index 000000000000..f220a374ae71 --- /dev/null +++ b/lib/libncurses/lib_slk.c @@ -0,0 +1,272 @@ + +/* + * lib_slk.c + * Soft key routines. + * + * Copyright (C) Gerhard Fuernkranz 1993 + * Permisson is granted to redistribute this + * code under the terms of the GNU Copyleft. + */ + +#include +#include "curses.priv.h" +#include +#include + +int _slk_format; /* format specified in slk_init() */ + +#define MAXCOLUMNS 135 +#define MAXLINES 66 +#define UNINITIALISED ((struct try * ) -1) +/* + * Retrieve label text. + */ + +char * +slk_label(int n) +{ +SLK *slk = SP->_slk; +#ifdef TRACE + if (_tracing) + _tracef("slk_label(%d)", n); +#endif + + if (slk == NULL || n < 1 || n > 8) + return NULL; + return slk->ent[n-1].text; +} + +/* + * Write the soft lables to the slk window. + */ + +static void +slk_intern_refresh(SLK *slk) +{ +int i; +#ifdef TRACE + if (_tracing) + _tracef("slk_intern_refresh(%x)", slk); +#endif + + for (i = 0; i < 8; i++) { + if (slk->dirty || slk->ent[i].dirty) { + if (slk->ent[i].visible) { + wmove(slk->win,0,slk->ent[i].x); + wattrset(slk->win,A_REVERSE); + waddstr(slk->win,slk->ent[i].form_text); + wattrset(slk->win,A_NORMAL); + } + slk->ent[i].dirty = FALSE; + } + } + slk->dirty = FALSE; +} + +/* + * Refresh the soft label window. + */ + +int +slk_noutrefresh(void) +{ +SLK *slk = SP->_slk; +#ifdef TRACE + if (_tracing) + _tracef("slk_noutrefresh()"); +#endif + + if (slk == NULL) + return ERR; + if (slk->hidden) + return OK; + slk_intern_refresh(slk); + return wnoutrefresh(slk->win); +} + +/* + * Refresh the soft label window. + */ + +int +slk_refresh(void) +{ +SLK *slk = SP->_slk; +#ifdef TRACE + if (_tracing) + _tracef("slk_refresh()"); +#endif + + if (slk == NULL) + return ERR; + if (slk->hidden) + return OK; + slk_intern_refresh(slk); + return wrefresh(slk->win); +} + +/* + * Restore the soft labels on the screen. + */ + +int +slk_restore(void) +{ +SLK *slk = SP->_slk; +#ifdef TRACE + if (_tracing) + _tracef("slk_restore()"); +#endif + + if (slk == NULL) + return ERR; + slk->hidden = FALSE; + slk->dirty = TRUE; + return slk_refresh(); +} + +/* + * Set soft label text. + */ + +int +slk_set(int i, char *str, int format) +{ +SLK *slk = SP->_slk; +int len; +#ifdef TRACE + if (_tracing) + _tracef("slk_set(%d, %s, %d)", i, str, format); +#endif + + if (slk == NULL || i < 1 || i > 8 || format < 0 || format > 2) + return ERR; + if (str == NULL) + str = ""; + i--; + strncpy(slk->ent[i].text,str,8); + memset(slk->ent[i].form_text,' ',8); + slk->ent[i].text[8] = 0; + slk->ent[i].form_text[8] = 0; + len = strlen(slk->ent[i].text); + switch(format) { + case 0: /* left */ + memcpy(slk->ent[i].form_text,slk->ent[i].text,len); + break; + case 1: /* center */ + memcpy(slk->ent[i].form_text+(8-len)/2,slk->ent[i].text,len); + break; + case 2: /* right */ + memcpy(slk->ent[i].form_text+8-len,slk->ent[i].text,len); + break; + } + slk->ent[i].dirty = TRUE; + return OK; +} + +/* + * Pretend, that soft keys have been changed. + */ + +int +slk_touch(void) +{ +SLK *slk = SP->_slk; +#ifdef TRACE + if (_tracing) + _tracef("slk_touch()"); +#endif + + if (slk == NULL) + return ERR; + slk->dirty = TRUE; + return OK; +} + +/* + * Remove soft labels from the screen. + */ + +int +slk_clear(void) +{ +SLK *slk = SP->_slk; +#ifdef TRACE + if (_tracing) + _tracef("slk_clear()"); +#endif + + if (slk == NULL) + return ERR; + slk->hidden = TRUE; + werase(slk->win); + return wrefresh(slk->win); +} + +/* + * Initialize soft labels. + * Called from newterm() + */ + +static int +slk_initialize(WINDOW *stwin, int cols) +{ +SLK *slk; +int i, maxlab, x; +#ifdef TRACE + if (_tracing) + _tracef("slk_initialize()"); +#endif + + if ((SP->_slk = slk = (SLK*) calloc(1,sizeof(SLK))) == NULL) + return OK; + maxlab = (cols+1)/9; + for (i = 0; i < 8; i++) { + memset(slk->ent[i].form_text,' ',8); + slk->ent[i].visible = i < maxlab; + } + if (_slk_format == 1) { /* 4-4 */ + int gap = cols - 64 - 6; + if (gap < 1) + gap = 1; + for (i = x = 0; i < 8; i++) { + slk->ent[i].x = x; + x += 8; + x += (i == 3) ? gap : 1; + } + } + else { /* 0 -> 3-2-3 */ + int gap = (cols - 64 - 5) / 2; + if (gap < 1) + gap = 1; + for (i = x = 0; i < 8; i++) { + slk->ent[i].x = x; + x += 8; + x += (i == 2 || i == 4) ? gap : 1; + } + } + slk->dirty = TRUE; + if ((slk->win = stwin) == NULL) + { + free(slk); + return ERR; + } + + return OK; +} + +/* + * Initialize soft labels. + * Called by the user. + */ + +int +slk_init(int format) +{ + if (format < 0 || format > 1) + return ERR; + _slk_format = format; + ripoffline(-1, slk_initialize); + return OK; +} + diff --git a/lib/libncurses/lib_touch.c b/lib/libncurses/lib_touch.c new file mode 100644 index 000000000000..4d291b3f33c1 --- /dev/null +++ b/lib/libncurses/lib_touch.c @@ -0,0 +1,48 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_touch.c +** +** The routines untouchwin(), +** wtouchln(), +** is_linetouched() +** is_wintouched(). +** +*/ + +#include "curses.priv.h" + +int is_linetouched(WINDOW *win, int line) +{ + if (line > win->_maxy || line < 0) + return ERR; + if (win->_firstchar[line] != _NOCHANGE) return TRUE; + return FALSE; +} + +int is_wintouched(WINDOW *win) +{ +int i; + + for (i = 0; i <= win->_maxy; i++) + if (win->_firstchar[i] != _NOCHANGE) + return TRUE; + return FALSE; +} + +int wtouchln(WINDOW *win, int y, int n, int changed) +{ +int i; + + T(("wtouchln(%x,%d,%d,%d)", win, y, n, changed)); + + for (i = y; i < y+n; i++) { + win->_firstchar[i] = changed ? 0 : _NOCHANGE; + win->_lastchar[i] = changed ? win->_maxx : _NOCHANGE; + } + return OK; +} + diff --git a/lib/libncurses/lib_trace.c b/lib/libncurses/lib_trace.c new file mode 100644 index 000000000000..c17f7dd9aaff --- /dev/null +++ b/lib/libncurses/lib_trace.c @@ -0,0 +1,170 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * lib_trace.c - Tracing/Debugging routines + */ + +#include +#include +#include +#include +#include +#include "curses.priv.h" +#include + +#if defined(BRAINDEAD) +extern int errno; +#endif + +int _tracing = 0; + +static int tracefd; + +void _tracef(char *fmt, ...); + +void _init_trace() +{ +static int been_here = 0; + + if (! been_here) { + been_here = 1; + + if ((tracefd = creat("trace", 0644)) < 0) { + write(2, "curses: Can't open 'trace' file: ", 33); + write(2, strerror(errno), strlen(strerror(errno))); + write(2, "\n", 1); + exit(1); + } + _tracef("TRACING NCURSES version %s", NCURSES_VERSION); + } +} + + +void traceon() +{ + + _tracing = 1; +} + + +void traceoff() +{ + + _tracing = 0; +} + +char *_traceattr(int newmode) +{ +static char buf[BUFSIZ]; +struct {unsigned int val; char *name;} +names[] = + { + {A_STANDOUT, "A_STANDOUT, ",}, + {A_UNDERLINE, "A_UNDERLINE, ",}, + {A_REVERSE, "A_REVERSE, ",}, + {A_BLINK, "A_BLINK, ",}, + {A_DIM, "A_DIM, ",}, + {A_BOLD, "A_BOLD, ",}, + {A_ALTCHARSET, "A_ALTCHARSET, ",}, + {A_INVIS, "A_INVIS, ",}, + {A_PROTECT, "A_PROTECT, ",}, + {A_CHARTEXT, "A_CHARTEXT, ",}, + {A_NORMAL, "A_NORMAL, ",}, + }, +colors[] = + { + {COLOR_BLACK, "COLOR_BLACK",}, + {COLOR_RED, "COLOR_RED",}, + {COLOR_GREEN, "COLOR_GREEN",}, + {COLOR_YELLOW, "COLOR_YELLOW",}, + {COLOR_BLUE, "COLOR_BLUE",}, + {COLOR_MAGENTA, "COLOR_MAGENTA",}, + {COLOR_CYAN, "COLOR_CYAN",}, + {COLOR_WHITE, "COLOR_WHITE",}, + }, + *sp; + + strcpy(buf, "{"); + for (sp = names; sp->val; sp++) + if (newmode & sp->val) + strcat(buf, sp->name); + if (newmode & A_COLOR) + { + int pairnum = PAIR_NUMBER(newmode); + + (void) sprintf(buf + strlen(buf), + "COLOR_PAIR(%d) = (%s, %s), ", + pairnum, + colors[BG(color_pairs[pairnum])].name, + colors[FG(color_pairs[pairnum])].name + ); + } + if ((newmode & A_ATTRIBUTES) == 0) + strcat(buf,"A_NORMAL, "); + if (buf[strlen(buf) - 2] == ',') + buf[strlen(buf) - 2] = '\0'; + return(strcat(buf,"}")); +} + +static char *visbuf(const char *buf) +/* visibilize a given string */ +{ + static char vbuf[BUFSIZ]; + char *tp = vbuf; + + while (*buf) + { + if (isprint(*buf) || *buf == ' ') + *tp++ = *buf++; + else if (*buf == '\n') + { + *tp++ = '\\'; *tp++ = 'n'; + buf++; + } + else if (*buf == '\r') + { + *tp++ = '\\'; *tp++ = 'r'; + buf++; + } + else if (*buf == '\b') + { + *tp++ = '\\'; *tp++ = 'b'; + buf++; + } + else if (*buf == '\033') + { + *tp++ = '\\'; *tp++ = 'e'; + buf++; + } + else if (*buf < ' ') + { + *tp++ = '\\'; *tp++ = '^'; *tp++ = '@' + *buf; + buf++; + } + else + { + (void) sprintf(tp, "\\0x%02x", *buf++); + tp += strlen(tp); + } + } + *tp++ = '\0'; + return(vbuf); +} + +void +_tracef(char *fmt, ...) +{ +va_list ap; +char buffer[256]; +char *vp; + + va_start(ap, fmt); + vsprintf(buffer, fmt, ap); + vp = visbuf(buffer); + write(tracefd, vp, strlen(vp)); + write(tracefd, "\n", 1); +} + diff --git a/lib/libncurses/lib_tstp.c b/lib/libncurses/lib_tstp.c new file mode 100644 index 000000000000..691dcd3e7196 --- /dev/null +++ b/lib/libncurses/lib_tstp.c @@ -0,0 +1,47 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_tstp.c +** +** The routine tstp(). +** +*/ + +#include "curses.priv.h" +#include +#ifdef SVR4_ACTION +#define _POSIX_SOURCE +#endif +#include + +void tstp(int dummy) +{ +sigaction_t act, oact; +sigset_t mask; + + T(("tstp() called")); + + endwin(); + + sigemptyset(&mask); + sigaddset(&mask, SIGTSTP); + sigprocmask(SIG_UNBLOCK, &mask, NULL); + + act.sa_handler = SIG_DFL; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; + sigaction(SIGTSTP, &act, &oact); + kill(getpid(), SIGTSTP); + + T(("SIGCONT received")); + sigaction(SIGTSTP, &oact, NULL); + reset_prog_mode(); + flushinp(); + if (enter_ca_mode) + tputs(enter_ca_mode, 1, _outc); + doupdate(); +} + diff --git a/lib/libncurses/lib_twait.c b/lib/libncurses/lib_twait.c new file mode 100644 index 000000000000..01e7ffaa12ac --- /dev/null +++ b/lib/libncurses/lib_twait.c @@ -0,0 +1,59 @@ +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_twait.c +** +** The routine timed_wait(). +** +*/ + +#include +#include +#include +#include "curses.priv.h" + +int timed_wait(int fd, int wait, int *timeleft) +{ +int result; +struct timeval timeout; +static fd_set set; +#ifndef GOOD_SELECT +struct timeval starttime, returntime; + + gettimeofday(&starttime, NULL); +#endif + + FD_ZERO(&set); + FD_SET(fd, &set); + + /* the units of wait are milliseconds */ + timeout.tv_sec = wait / 1000; + timeout.tv_usec = (wait % 1000) * 1000; + + T(("start twait: sec = %d, usec = %d", timeout.tv_sec, timeout.tv_usec)); + + result = select(fd+1, &set, NULL, NULL, &timeout); + +#ifndef GOOD_SELECT + gettimeofday(&returntime, NULL); + timeout.tv_sec -= (returntime.tv_sec - starttime.tv_sec); + timeout.tv_usec -= (returntime.tv_usec - starttime.tv_usec); + if (timeout.tv_usec < 0 && timeout.tv_sec > 0) { + timeout.tv_sec--; + timeout.tv_usec += 1000000; + } + if (timeout.tv_sec < 0) + timeout.tv_sec = timeout.tv_usec = 0; +#endif + + /* return approximate time left on the timeout, in milliseconds */ + if (timeleft) + *timeleft = (timeout.tv_sec * 1000) + (timeout.tv_usec / 1000); + + T(("end twait: returned %d, sec = %d, usec = %d (%d msec)", + result, timeout.tv_sec, timeout.tv_usec, *timeleft)); + + return(result); +} diff --git a/lib/libncurses/lib_unctrl.c b/lib/libncurses/lib_unctrl.c new file mode 100644 index 000000000000..3c8f5831fb60 --- /dev/null +++ b/lib/libncurses/lib_unctrl.c @@ -0,0 +1,26 @@ +#include +#include + +char * + unctrl(register unsigned char uch) +{ + static char buffer[3] = "^x"; + + if (isgraph(uch)) { + /* + * Printable character. Simply return the character as a one-character + * string. + */ + buffer[1] = uch; + return &buffer[1]; + } + uch &= ~0x80; + /* + * It is a control character. DEL is handled specially (^?). All others + * use ^x notation, where x is the character code for the control character + * with 0x40 ORed in. (Control-A becomes ^A etc.). + */ buffer[1] = (uch == 0x7F ? '?' : (uch | 0x40)); + + return buffer; + +} diff --git a/lib/libncurses/lib_vidattr.c b/lib/libncurses/lib_vidattr.c new file mode 100644 index 000000000000..a3bd4c7ed526 --- /dev/null +++ b/lib/libncurses/lib_vidattr.c @@ -0,0 +1,185 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* + * vidputs(newmode, outc) + * + * newmode is taken to be the logical 'or' of the symbols in curses.h + * representing graphic renditions. The teminal is set to be in all of + * the given modes, if possible. + * + * if set-attributes exists + * use it to set exactly what you want + * else + * if exit-attribute-mode exists + * turn off everything + * else + * turn off those which can be turned off and aren't in + * newmode. + * turn on each mode which should be on and isn't, one by one + * + * NOTE that this algorithm won't achieve the desired mix of attributes + * in some cases, but those are probably just those cases in which it is + * actually impossible, anyway, so... + * + */ + +#include +#include "curses.priv.h" +#include + +static void do_color(int pair, int (*outc)(char)) +{ +short fg, bg; + + if ( pair == 0 ) { + tputs(orig_pair, 1, outc); + } else { + fg = FG(color_pairs[pair]); + bg = BG(color_pairs[pair]); + + T(("setting colors: pair = %d, fg = %d, bg = %d\n", pair, fg, bg)); + + if (set_a_foreground) + tputs(tparm(set_a_foreground, fg), 1, outc); + else + tputs(tparm(set_foreground, fg), 1, outc); + if (set_a_background) + tputs(tparm(set_a_background, bg), 1, outc); + else + tputs(tparm(set_background, bg), 1, outc); + } +} + +static int current_pair = 0; +static chtype previous_attr = 0; + +int vidputs(chtype newmode, int (*outc)(char)) +{ +chtype turn_off, turn_on; + + T(("vidputs(%x) called %s", newmode, _traceattr(newmode))); + T(("previous attribute was %s", _traceattr(previous_attr))); + + if (newmode == A_NORMAL && exit_attribute_mode) { + tputs(exit_attribute_mode, 1, outc); + current_pair = -1; + goto set_color; + } + else if (set_attributes) { + tputs(tparm(set_attributes, + (newmode & A_STANDOUT) != 0, + (newmode & A_UNDERLINE) != 0, + (newmode & A_REVERSE) != 0, + (newmode & A_BLINK) != 0, + (newmode & A_DIM) != 0, + (newmode & A_BOLD) != 0, + (newmode & A_INVIS) != 0, + (newmode & A_PROTECT) != 0, + (newmode & A_ALTCHARSET) != 0), 1, outc); + goto set_color; + } else { + if (exit_attribute_mode) { + if((previous_attr & A_ALTCHARSET) && exit_alt_charset_mode) { + tputs(exit_alt_charset_mode, 1, outc); + previous_attr &= ~A_ALTCHARSET; + } + if (previous_attr) { + T(("exiting attribute mode")); + + tputs(exit_attribute_mode, 1, outc); + previous_attr = 0; + current_pair = -1; + } + } else { + turn_off = ~newmode & previous_attr; + + T(("turning %x off", turn_off)); + + if ((turn_off & A_ALTCHARSET) && exit_alt_charset_mode) + tputs(exit_alt_charset_mode, 1, outc); + + if ((turn_off & A_BOLD) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + + if ((turn_off & A_DIM) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + + if ((turn_off & A_BLINK) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + + if ((turn_off & A_INVIS) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + + if ((turn_off & A_PROTECT) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + + if ((turn_off & A_UNDERLINE) && exit_underline_mode) + tputs(exit_underline_mode, 1, outc); + + if ((turn_off & A_REVERSE) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + + if ((turn_off & A_STANDOUT) && exit_standout_mode) + tputs(exit_standout_mode, 1, outc); + } + + turn_on = newmode & ~previous_attr; + + T(("turning %x on", turn_on)); + + if ((turn_on & A_ALTCHARSET) && enter_alt_charset_mode) + tputs(enter_alt_charset_mode, 1, outc); + + if ((turn_on & A_BLINK) && enter_blink_mode) + tputs(enter_blink_mode, 1, outc); + + if ((turn_on & A_BOLD) && enter_bold_mode) + tputs(enter_bold_mode, 1, outc); + + if ((turn_on & A_DIM) && enter_dim_mode) + tputs(enter_dim_mode, 1, outc); + + if ((turn_on & A_REVERSE) && enter_reverse_mode) + tputs(enter_reverse_mode, 1, outc); + + if ((turn_on & A_STANDOUT) && enter_standout_mode) + tputs(enter_standout_mode, 1, outc); + + if ((turn_on & A_PROTECT) && enter_protected_mode) + tputs(enter_protected_mode, 1, outc); + + if ((turn_on & A_INVIS) && enter_secure_mode) + tputs(enter_secure_mode, 1, outc); + + if ((turn_on & A_UNDERLINE) && enter_underline_mode) + tputs(enter_underline_mode, 1, outc); + set_color: + if (_coloron) { + int pair = PAIR_NUMBER(newmode); + + T(("old pair = %d -- new pair = %d", current_pair, pair)); + if (pair != current_pair) { + current_pair = pair; + do_color(pair, outc); + } + } + } + + + previous_attr = newmode; + + T(("vidputs finished")); + return OK; +} + +int vidattr(chtype newmode) +{ + + T(("vidattr(%x) called", newmode)); + + return(vidputs(newmode, _outc)); +} + diff --git a/lib/libncurses/lib_window.c b/lib/libncurses/lib_window.c new file mode 100644 index 000000000000..ec18694f7f94 --- /dev/null +++ b/lib/libncurses/lib_window.c @@ -0,0 +1,84 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +/* +** lib_window.c +** +** +*/ + +#include +#include "curses.priv.h" + +int mvder(WINDOW *win, int y, int x) +{ + +} + +void wsyncup(WINDOW *win) +{ + +} + +int syncok(WINDOW *win, bool bf) +{ + +} + +void wcursyncup(WINDOW *win) +{ + +} + +void wsyncdown(WINDOW *win) +{ + +} + +WINDOW *dupwin(WINDOW *win) +{ +WINDOW *nwin; +#ifdef TRACE + if (_tracing) + _tracef("dupwin(%x) called", win); +#endif + + if ((nwin = newwin(win->_maxy, win->_maxx, win->_bey, win->_begx)) == NULL) + return NULL; + + nwin->_curx = win->_curx; + nwin->_cury = win->_cury; + nwin->_maxy = win->_maxy; + nwin->_maxx = win->_maxx; + nwin->_begy = win->_begy; + nwin->_begx = win->_begx; + + nwin->_flags = win->_flags; + nwin->_attrs = win->_attrs; + + nwin->_clear = win->_clear; + nwin->_scroll = win->_scroll; + nwin->_leave = win->_leave; + nwin->_use_keypad = win->_use_keypad; + nwin->_use_meta = win->_use_meta; + nwin->_delay = win->_delay; + nwin->_immed = win->_immed; + nwin->_sync = win->_sync; + nwin->_parx = win->_parx; + nwin->_pary = win->_pary; + nwin->_parent = win->_parent; + + nwin->_regtop = win->_regtop; + nwin->_regbottom = win->_regbottom; + + for (i = 0; i < nwin->_cury; i++) { + memcpy(nwin->_line[i], win->_line[i], win->_maxx * sizeof(chtype)); + nwin->_firstchar[i] = win->_firstchar[i]; + nwin->_lastchar[i] = win->_lastchar[i]; + } + + return nwin; +} + diff --git a/lib/libncurses/ncurses.3 b/lib/libncurses/ncurses.3 new file mode 100644 index 000000000000..e8d74bb760df --- /dev/null +++ b/lib/libncurses/ncurses.3 @@ -0,0 +1,433 @@ +.TH ncurses 3X "" +.ds n 5 +.ds d /usr/lib/terminfo +.SH NAME +\fBncurses\fR - CRT screen handling and optimization package +.SH SYNOPSIS +\fB#include \fR +.br +.SH DESCRIPTION +The \fBncurses\fR library routines give the user a terminal-independent +method of updating character screens with reasonable optimization. + +The \fBncurses\fR routines emulate the \fBcurses\fR(3X) library of System V +Release 4 UNIX, but is freely redistributable in source form. Differences from +the SVr4 curses are described in the BUGS sections of individual man pages. +There are only few of these, and as ncurses matures they will become fewer +still. + +A program using these routines must be linked with the \fB-lncurses\fR option, +or (if they have been generated) with one of the debugging libraries +\fB-ldcurses\fR or \fB-lpcurses\fR. The dcurses library generates trace logs +that describe curses actions; the pcurses library supports profiling. + +The \fBncurses\fR package supports: overall screen, window and pad +manipulation; output to windows and pads; reading terminal input; control over +terminal and \fBncurses\fR input and output options; environment query +routines; color manipulation; use of soft label keys; terminfo capabilities; +and access to low-level \fBncurses\fR routines. + +To initialize the routines, the routine \fBinitscr\fR or \fBnewterm\fR +must be called before any of the other routines that deal with windows +and screens are used. The routine \fBendwin\fR must be called before +exiting. To get character-at-a-time input without echoing (most +interactive, screen oriented programs want this), the following +sequence should be used: + + \fBinitscr(); cbreak(); noecho;\fR + +Most programs would additionally use the sequence: + + \fBnonl(); intrflush(stdscr,FALSE); keypad(stdscr,TRUE);\fR + +Before a \fBncurses\fR program is run, the tab stops of the terminal +should be set and its initialization strings, if defined, must be +output. This can be done by executing the \fBtput init\fR command +after the shell environment variable \fBTERM\fR has been exported. +[See \fBterminfo\fR(\*n) for further details.] + +The \fBncurses\fR library permits manipulation of data structures, +called \fIwindows\fR, which can be thought of as two-dimensional +arrays of characters representing all or part of a CRT screen. A +default window called \fBstdscr\fR, which is the size of the terminal +screen, is supplied. Others may be created with \fBnewwin\fR. + +Windows are referred to by variables declared as \fBWINDOW *\fR. +These data structures are manipulated with routines described on 3X +pages (whose names begin "curs_"). Among which the most basic +routines are \fBmove\fR and \fBaddch\fR. More general versions of +these routines are included with names beginning with \fBw\fR, +allowing the user to specify a window. The routines not beginning +with \fBw\fR affect \fBstdscr\fR.) + +After using routines to manipulate a window, \fBrefresh\fR is called, +telling \fBncurses\fR to make the user's CRT screen look like +\fBstdscr\fR. The characters in a window are actually of type +\fBchtype\fR, (character and attribute data) so that other information +about the character may also be stored with each character. + +Special windows called \fIpads\fR may also be manipulated. These are windows +which are not constrained to the size of the screen and whose contents need not +be completely displayed. See curs_pad(3X) for more information. + +In addition to drawing characters on the screen, video attributes and colors +may be supported, causing the characters to show up in such modes as +underlined, in reverse video, or in color on terminals that support such +display enhancements. Line drawing characters may be specified to be output. +On input, \fBncurses\fR is also able to translate arrow and function keys that +transmit escape sequences into single values. The video attributes, line +drawing characters, and input values use names, defined in \fB\fR, +such as \fBA_REVERSE\fR, \fBACS_HLINE\fR, and \fBKEY_LEFT\fR. + +If the environment variables \fBLINES\fR and \fBCOLUMNS\fR are set, or if the +program is executing in a window environment, line and column information in +the environment will override information read by \fIterminfo\fR. This would +effect a program running in an AT&T 630 layer, for example, where the size of a +screen is changeable. + +If the environment variable \fBTERMINFO\fR is defined, any program using +\fBncurses\fR checks for a local terminal definition before checking in the +standard place. For example, if \fBTERM\fR is set to \fBatt4424\fR, then the +compiled terminal definition is found in + + \fB\*d/a/att4424\fR. + +(The \fBa\fR is copied from the first letter of \fBatt4424\fR to avoid +creation of huge directories.) However, if \fBTERMINFO\fR is set to +\fB$HOME/myterms\fR, \fBncurses\fR first checks + + \fB$HOME/myterms/a/att4424\fR, + +and if that fails, it then checks + + \fB\*d/a/att4424\fR. + +This is useful for developing experimental definitions or when write +permission in \fB\*d\fR is not available. + +The integer variables \fBLINES\fR and \fBCOLS\fR are defined in +\fB\fR and will be filled in by \fBinitscr\fR with the size of the +screen. The constants \fBTRUE\fR and \fBFALSE\fR have the values \fB1\fR and +\fB0\fR, respectively. + +The \fBncurses\fR routines also define the \fBWINDOW *\fR variable \fBcurscr\fR +which is used for certain low-level operations like clearing and redrawing a +screen containing garbage. The \fBcurscr\fR can be used in only a few +routines. + +.SS Routine and Argument Names +Many \fBncurses\fR routines have two or more versions. The routines prefixed +with \fBw\fR require a window argument. The routines prefixed with \fBp\fR +require a pad argument. Those without a prefix generally use \fBstdscr\fR. + +The routines prefixed with \fBmv\fR require a \fIy\fR and \fIx\fR +coordinate to move to before performing the appropriate action. The +\fBmv\fR routines imply a call to \fBmove\fR before the call to the +other routine. The coordinate \fIy\fR always refers to the row (of +the window), and \fIx\fR always refers to the column. The upper +left-hand corner is always (0,0), not (1,1). + +The routines prefixed with \fBmvw\fR take both a window argument and +\fIx\fR and \fIy\fR coordinates. The window argument is always +specified before the coordinates. + +In each case, \fIwin\fR is the window affected, and \fIpad\fR is the +pad affected; \fIwin\fR and \fIpad\fR are always pointers to type +\fBWINDOW\fR. + +Option setting routines require a Boolean flag \fIbf\fR with the value +\fBTRUE\fR or \fBFALSE\fR; \fIbf\fR is always of type \fBbool\fR. The +variables \fIch\fR and \fIattrs\fR below are always of type +\fBchtype\fR. The types \fBWINDOW\fR, \fBSCREEN\fR, \fBbool\fR, and +\fBchtype\fR are defined in \fB\fR. The type \fBTERMINAL\fR +is defined in \fB\fR. All other arguments are integers. + +.SS Routine Name Index +The following table lists each \fBncurses\fR routine and the name of +the manual page on which it is described. + +.nf +\fBncurses\fR Routine Name Manual Page Name +___________________________________________ +addch curs_addch(3X) +addchnstr curs_addchstr(3X) +addchstr curs_addchstr(3X) +addnstr curs_addstr(3X) +addstr curs_addstr(3X) +attroff curs_attr(3X) +attron curs_attr(3X) +attrset curs_attr(3X) +baudrate curs_termattrs(3X) +beep curs_beep(3X) +bkgd curs_bkgd(3X) +bkgdset curs_bkgd(3X) +border curs_border(3X) +box curs_border(3X) +can_change_color curs_color(3X) +cbreak curs_inopts(3X) +clear curs_clear(3X) +clearok curs_outopts(3X) +clrtobot curs_clear(3X) +clrtoeol curs_clear(3X) +color_content curs_color(3X) +copywin curs_overlay(3X) +curs_set curs_kernel(3X) +def_prog_mode curs_kernel(3X) +def_shell_mode curs_kernel(3X) +del_curterm curs_terminfo(\*n) +delay_output curs_util(3X) +delch curs_delch(3X) +deleteln curs_deleteln(3X) +delscreen curs_initscr(3X) +delwin curs_window(3X) +derwin curs_window(3X) +doupdate curs_refresh(3X) +dupwin curs_window(3X) +echo curs_inopts(3X) +echochar curs_addch(3X) +endwin curs_initscr(3X) +erase curs_clear(3X) +erasechar curs_termattrs(3X) +filter curs_util(3X) +flash curs_beep(3X) +flushinp curs_util(3X) +getbegyx curs_getyx(3X) +getch curs_getch(3X) +getmaxyx curs_getyx(3X) +getparyx curs_getyx(3X) +getstr curs_getstr(3X) +getsyx curs_kernel(3X) +getwin curs_util(3X) +getyx curs_getyx(3X) +halfdelay curs_inopts(3X) +has_colors curs_color(3X) +has_ic curs_termattrs(3X) +has_il curs_termattrs(3X) +hline curs_border(3X) +idcok curs_outopts(3X) +idlok curs_outopts(3X) +immedok curs_outopts(3X) +inch curs_inch(3X) +inchnstr curs_inchstr(3X) +inchstr curs_inchstr(3X) +init_color curs_color(3X) +init_pair curs_color(3X) +initscr curs_initscr(3X) +innstr curs_instr(3X) +insch curs_insch(3X) +insdelln curs_deleteln(3X) +insertln curs_deleteln(3X) +insnstr curs_insstr(3X) +insstr curs_insstr(3X) +instr curs_instr(3X) +intrflush curs_inopts(3X) +is_linetouched curs_touch(3X) +is_wintouched curs_touch(3X) +isendwin curs_initscr(3X) +keyname curs_util(3X) +keypad curs_inopts(3X) +killchar curs_termattrs(3X) +leaveok curs_outopts(3X) +longname curs_termattrs(3X) +meta curs_inopts(3X) +move curs_move(3X) +mvaddch curs_addch(3X) +mvaddchnstr curs_addchstr(3X) +mvaddchstr curs_addchstr(3X) +mvaddnstr curs_addstr(3X) +mvaddstr curs_addstr(3X) +mvcur curs_terminfo(\*n) +mvdelch curs_delch(3X) +mvderwin curs_window(3X) +mvgetch curs_getch(3X) +mvgetstr curs_getstr(3X) +mvinch curs_inch(3X) +mvinchnstr curs_inchstr(3X) +mvinchstr curs_inchstr(3X) +mvinnstr curs_instr(3X) +mvinsch curs_insch(3X) +mvinsnstr curs_insstr(3X) +mvinsstr curs_insstr(3X) +mvinstr curs_instr(3X) +mvprintw curs_printw(3X) +mvscanw curs_scanw(3X) +mvwaddch curs_addch(3X) +mvwaddchnstr curs_addchstr(3X) +mvwaddchstr curs_addchstr(3X) +mvwaddnstr curs_addstr(3X) +mvwaddstr curs_addstr(3X) +mvwdelch curs_delch(3X) +mvwgetch curs_getch(3X) +mvwgetstr curs_getstr(3X) +mvwin curs_window(3X) +mvwinch curs_inch(3X) +mvwinchnstr curs_inchstr(3X) +mvwinchstr curs_inchstr(3X) +mvwinnstr curs_instr(3X) +mvwinsch curs_insch(3X) +mvwinsnstr curs_insstr(3X) +mvwinsstr curs_insstr(3X) +mvwinstr curs_instr(3X) +mvwprintw curs_printw(3X) +mvwscanw curs_scanw(3X) +napms curs_kernel(3X) +newpad curs_pad(3X) +newterm curs_initscr(3X) +newwin curs_window(3X) +nl curs_outopts(3X) +nocbreak curs_inopts(3X) +nodelay curs_inopts(3X) +noecho curs_inopts(3X) +nonl curs_outopts(3X) +noqiflush curs_inopts(3X) +noraw curs_inopts(3X) +notimeout curs_inopts(3X) +overlay curs_overlay(3X) +overwrite curs_overlay(3X) +pair_content curs_color(3X) +pechochar curs_pad(3X) +pnoutrefresh curs_pad(3X) +prefresh curs_pad(3X) +printw curs_printw(3X) +putp curs_terminfo(\*n) +putwin curs_util(3X) +qiflush curs_inopts(3X) +raw curs_inopts(3X) +redrawwin curs_refresh(3X) +refresh curs_refresh(3X) +reset_prog_mode curs_kernel(3X) +reset_shell_mode curs_kernel(3X) +resetty curs_kernel(3X) +restartterm curs_terminfo(\*n) +ripoffline curs_kernel(3X) +savetty curs_kernel(3X) +scanw curs_scanw(3X) +scr_dump curs_scr_dump(3X) +scr_init curs_scr_dump(3X) +scr_restore curs_scr_dump(3X) +scr_set curs_scr_dump(3X) +scrl curs_scroll(3X) +scroll curs_scroll(3X) +scrollok curs_outopts(3X) +set_curterm curs_terminfo(\*n) +set_term curs_initscr(3X) +setscrreg curs_outopts(3X) +setsyx curs_kernel(3X) +setterm curs_terminfo(\*n) +setupterm curs_terminfo(\*n) +slk_attroff curs_slk(3X) +slk_attron curs_slk(3X) +slk_attrset curs_slk(3X) +slk_clear curs_slk(3X) +slk_init curs_slk(3X) +slk_label curs_slk(3X) +slk_noutrefresh curs_slk(3X) +slk_refresh curs_slk(3X) +slk_restore curs_slk(3X) +slk_set curs_slk(3X) +slk_touch curs_slk(3X) +standend curs_attr(3X) +standout curs_attr(3X) +start_color curs_color(3X) +subpad curs_pad(3X) +subwin curs_window(3X) +syncok curs_window(3X) +termattrs curs_termattrs(3X) +termname curs_termattrs(3X) +tgetent curs_termcap(3X) +tgetflag curs_termcap(3X) +tgetnum curs_termcap(3X) +tgetstr curs_termcap(3X) +tgoto curs_termcap(3X) +tigetflag curs_terminfo(\*n) +tigetnum curs_terminfo(\*n) +tigetstr curs_terminfo(\*n) +timeout curs_inopts(3X) +touchline curs_touch(3X) +touchwin curs_touch(3X) +tparm curs_terminfo(\*n) +tputs curs_termcap(3X) +tputs curs_terminfo(\*n) +typeahead curs_inopts(3X) +unctrl curs_util(3X) +ungetch curs_getch(3X) +untouchwin curs_touch(3X) +use_env curs_util(3X) +vidattr curs_terminfo(\*n) +vidputs curs_terminfo(\*n) +vline curs_border(3X) +vwprintw curs_printw(3X) +vwscanw curs_scanw(3X) +waddch curs_addch(3X) +waddchnstr curs_addchstr(3X) +waddchstr curs_addchstr(3X) +waddnstr curs_addstr(3X) +waddstr curs_addstr(3X) +wattroff curs_attr(3X) +wattron curs_attr(3X) +wattrset curs_attr(3X) +wbkgd curs_bkgd(3X) +wbkgdset curs_bkgd(3X) +wborder curs_border(3X) +wclear curs_clear(3X) +wclrtobot curs_clear(3X) +wclrtoeol curs_clear(3X) +wcursyncup curs_window(3X) +wdelch curs_delch(3X) +wdeleteln curs_deleteln(3X) +wechochar curs_addch(3X) +werase curs_clear(3X) +wgetch curs_getch(3X) +wgetnstr curs_getstr(3X) +wgetstr curs_getstr(3X) +whline curs_border(3X) +winch curs_inch(3X) +winchnstr curs_inchstr(3X) +winchstr curs_inchstr(3X) +winnstr curs_instr(3X) +winsch curs_insch(3X) +winsdelln curs_deleteln(3X) +winsertln curs_deleteln(3X) +winsnstr curs_insstr(3X) +winsstr curs_insstr(3X) +winstr curs_instr(3X) +wmove curs_move(3X) +wnoutrefresh curs_refresh(3X) +wprintw curs_printw(3X) +wredrawln curs_refresh(3X) +wrefresh curs_refresh(3X) +wscanw curs_scanw(3X) +wscrl curs_scroll(3X) +wsetscrreg curs_outopts(3X) +wstandend curs_attr(3X) +wstandout curs_attr(3X) +wsyncdown curs_window(3X) +wsyncup curs_window(3X) +wtimeout curs_inopts(3X) +wtouchln curs_touch(3X) +wvline curs_border(3X) +.fi +.SH RETURN VALUE +Routines that return an integer return \fBERR\fR upon failure and an +integer value other than \fBERR\fR upon successful completion, unless +otherwise noted in the routine descriptions. + +All macros return the value of the \fBw\fR version, except \fBsetscrreg\fR, +\fBwsetscrreg\fR, \fBgetyx\fR, \fBgetbegyx\fR, \fBgetmaxyx\fR. The return +values of \fBsetscrreg\fR, \fBwsetscrreg\fR, \fBgetyx\fR, \fBgetbegyx\fR, and +\fBgetmaxyx\fR are undefined (\fIi\fR.\fIe\fR., these should not be used as the +right-hand side of assignment statements). + +Routines that return pointers return \fBNULL\fR on error. +.SH SEE ALSO +\fBterminfo\fR(\*n) and 3X pages whose names begin "curs_" for detailed routine +descriptions. +.SH NOTES +The header file \fB\fR automatically includes the header files +\fB\fR and \fB\fR. +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/ncurses.h b/lib/libncurses/ncurses.h new file mode 100644 index 000000000000..743a50b84d9f --- /dev/null +++ b/lib/libncurses/ncurses.h @@ -0,0 +1,497 @@ + +/* This work is copyrighted. See COPYRIGHT.OLD & COPYRIGHT.NEW for * +* details. If they are missing then this copy is in violation of * +* the copyright conditions. */ + +#ifndef __NCURSES_H +#define __NCURSES_H +#define CURSES 1 +#define CURSES_H 1 + +#include +#include +#ifndef NOTERMIOS +#include +#else +#include +#include +#endif +#include + +#define bool char + +typedef unsigned long chtype; + +/* attributes */ +#define A_ATTRIBUTES 0xffffff00 +#define A_NORMAL 0x00000000 +#define A_STANDOUT 0x00010000 +#define A_UNDERLINE 0x00020000 +#define A_REVERSE 0x00040000 +#define A_BLINK 0x00080000 +#define A_DIM 0x00100000 +#define A_BOLD 0x00200000 +#define A_ALTCHARSET 0x00400000 +#define A_INVIS 0x00800000 +#define A_PROTECT 0x01000000 +#define A_CHARTEXT 0x000000ff +#define A_COLOR 0x0000ff00 +#define COLOR_PAIR(n) (n << 8) +#define PAIR_NUMBER(a) ((a & A_COLOR) >> 8) + +/* colors */ +extern int COLORS; +extern int COLOR_PAIRS; +extern unsigned char color_pairs[]; + +#define COLOR_BLACK 0 +#define COLOR_RED 1 +#define COLOR_GREEN 2 +#define COLOR_YELLOW 3 +#define COLOR_BLUE 4 +#define COLOR_MAGENTA 5 +#define COLOR_CYAN 6 +#define COLOR_WHITE 7 + +/* line graphics */ + +extern chtype acs_map[]; + + +#define ACS_ULCORNER (acs_map['l']) +#define ACS_LLCORNER (acs_map['m']) +#define ACS_URCORNER (acs_map['k']) +#define ACS_LRCORNER (acs_map['j']) +#define ACS_RTEE (acs_map['u']) +#define ACS_LTEE (acs_map['t']) +#define ACS_BTEE (acs_map['v']) +#define ACS_TTEE (acs_map['w']) +#define ACS_HLINE (acs_map['q']) +#define ACS_VLINE (acs_map['x']) +#define ACS_PLUS (acs_map['n']) +#define ACS_S1 (acs_map['o']) /* scan line 1 */ +#define ACS_S9 (acs_map['s']) /* scan line 9 */ +#define ACS_DIAMOND (acs_map['`']) /* diamond */ +#define ACS_CKBOARD (acs_map['a']) /* checker board (stipple) */ +#define ACS_DEGREE (acs_map['f']) /* degree symbol */ +#define ACS_PLMINUS (acs_map['g']) /* plus/minus */ +#define ACS_BULLET (acs_map['~']) /* bullet */ +#define ACS_LARROW (acs_map[',']) /* arrow pointing left */ +#define ACS_RARROW (acs_map['+']) /* arrow pointing right */ +#define ACS_DARROW (acs_map['.']) /* arrow pointing down */ +#define ACS_UARROW (acs_map['-']) /* arrow pointing up */ +#define ACS_BOARD (acs_map['h']) /* board of squares */ +#define ACS_LANTERN (acs_map['I']) /* lantern symbol */ +#define ACS_BLOCK (acs_map['0']) /* solid square block */ + +#ifndef TRUE +# define TRUE (1) +# define FALSE (0) +#endif + +#define ERR (-1) +#define OK (0) + +#define _SUBWIN 0x01 +#define _ENDLINE 0x02 +#define _FULLWIN 0x04 +#define _SCROLLWIN 0x08 +#define _ISPAD 0x10 +#define _HASMOVED 0x20 + +#define _NOCHANGE -1 + +typedef struct screen SCREEN; +typedef struct _win_st WINDOW; + +struct _win_st { + short _cury, _curx; /* current cursor position */ + short _maxy, _maxx; /* maximum values of x and y NOT the screen dimensions */ + short _begy, _begx; + short _flags; + chtype _attrs; + chtype _bkgd; + + /* The following should be consolidated into one bitset */ + bool _notimeout; + bool _use_idc; + bool _clear; + bool _leave; + bool _scroll; + bool _idlok; + bool _immed; + bool _sync; + bool _use_keypad; /* 0=no, 1=yes */ + bool _use_meta; /* T=use the meta key */ + + int _delay; /* 0 = nodelay + <0 = blocking + >0 = delay */ + chtype **_line; + short *_firstchar; /* First changed character in the line */ + short *_lastchar; /* Last changed character in the line */ + short _regtop; /* Top and bottom of scrolling region */ + short _regbottom; + int _parx; + int _pary; + WINDOW *_parent; /* parent if a sub-window */ +}; + +extern WINDOW *stdscr, *curscr; + +extern int LINES, COLS; + +#ifdef __cplusplus +extern "C" { +#endif + +extern char ttytype[]; /* needed for backward compatibility */ + +extern int tigetflag(char *); +extern int tigetnum(char *); +extern char *tigetstr(char *); + +/* Debugging : use with libdcurses.a */ + +extern void _init_trace(void); +extern void _tracef(char *, ...); +extern char *_traceattr(int mode); +extern void traceon(void); +extern void traceoff(void); + +/* function prototypes */ + +extern int baudrate(void); +extern int beep(void); +extern int cbreak(void); +extern int clearok(WINDOW *,int); +extern int copywin(WINDOW *,WINDOW *,int,int,int,int,int,int,int); +extern int crmode(void); +extern int curs_set(int); +extern int def_prog_mode(void); +extern int def_shell_mode(void); +extern int delwin(WINDOW *); +extern WINDOW *derwin(WINDOW *,int,int,int,int); +extern int doupdate(void); +extern int echo(void); +extern int endwin(void); +extern char erasechar(void); +extern int flash(void); +extern int flushinp(void); +extern int idlok(WINDOW *,int); +extern int is_linetouched(WINDOW *,int); +extern int is_wintouched(WINDOW *); +extern WINDOW *initscr(void); +extern int isendwin(void); +extern char *keyname(int); +extern int keypad(WINDOW *,int); +extern char killchar(void); +extern int leaveok(WINDOW *,int); +extern char *longname(void); +extern int meta(WINDOW *,int); +extern int mvcur(int,int,int,int); +extern int mvprintw(int,int,char *,...); +extern int mvscanw(int,int,char *,...); +extern int mvwin(WINDOW *,int,int); +extern int mvwprintw(WINDOW *,int,int,char *,...); +extern int mvwscanw(WINDOW *,int,int,char *,...); +extern WINDOW *newpad(int,int); +extern SCREEN *newterm(char *,FILE *,FILE *); +extern WINDOW *newwin(int,int,int,int); +extern int nl(void); +extern int nocbreak(void); +extern int nocrmode(void); +extern int nodelay(WINDOW *,int); +extern int noecho(void); +extern int nonl(void); +extern int noraw(void); +extern int overlay(WINDOW *,WINDOW *); +extern int overwrite(WINDOW *,WINDOW *); +extern int pnoutrefresh(WINDOW *,int,int,int,int,int,int); +extern int prefresh(WINDOW *,int,int,int,int,int,int); +extern int printw(char *,...); +extern int putp(char *); +extern int raw(void); +extern int reset_prog_mode(void); +extern int reset_shell_mode(void); +extern int resetty(void); +extern int ripoffline(int line, int (*init)(WINDOW *, int)); +extern int savetty(void); +extern int scanw(char *,...); +extern int scrollok(WINDOW *,int); +extern SCREEN *set_term(SCREEN *); +extern int setupterm(char *,int,int *); +extern WINDOW *subwin(WINDOW *,int,int,int,int); +extern char *tgoto(char *,int,int); +extern int timeout(int); +extern char *tparm(char *, ...); +extern int tputs(char *,int,int (*)(char)); +extern int ungetch(int); +extern int vidattr(chtype); +extern int vidputs(chtype,int (*)(char)); +extern int vwscanw(WINDOW *,char *,va_list); +extern int vwprintw(WINDOW *,char *,va_list); +extern int waddch(WINDOW *,chtype); +extern int waddchnstr(WINDOW *,chtype *,int); +extern int waddnstr(WINDOW *,char *,int); +extern int wattron(WINDOW *,chtype); +extern int wborder(WINDOW *,chtype,chtype,chtype,chtype,chtype,chtype,chtype,chtype); +extern int wclear(WINDOW *); +extern int wclrtobot(WINDOW *); +extern int wclrtoeol(WINDOW *); +extern int wdelch(WINDOW *); +extern int wdeleteln(WINDOW *); +extern int werase(WINDOW *); +extern int wgetch(WINDOW *); +extern int wgetnstr(WINDOW *,char *,int maxlen); +extern int whline(WINDOW *,chtype,int); +extern int winsch(WINDOW *,chtype); +extern int winsdel(WINDOW *,int); +extern int winsertln(WINDOW *); +extern int winsnstr(WINDOW *,char *,int); +extern int wmove(WINDOW *,int,int); +extern int wnoutrefresh(WINDOW *); +extern int wprintw(WINDOW *,char *,...); +extern int redrawln(WINDOW *,int,int); +extern int wrefresh(WINDOW *); +extern int wscanw(WINDOW *,char *,...); +extern int wscrl(WINDOW *,int); +extern int wsetscrreg(WINDOW *,int,int); +extern int wtimeout(WINDOW *,int); +extern int wtouchln(WINDOW *,int,int,int); +extern int wvline(WINDOW *,chtype,int); + +extern bool can_change_color(void); +extern int color_content(short,short *,short *, short *); +extern int has_colors(void); +extern int init_color(short,short,short,short); +extern int init_pair(short,short,short); +extern int pair_content(short,short*,short*); +extern int start_color(void); + +extern int slk_init(int); +extern int slk_set(int,char *,int); +extern int slk_refresh(void); +extern int slk_noutrefresh(void); +extern char *slk_label(int); +extern int slk_clear(void); +extern int slk_restore(void); +extern int slk_touch(void); + +#ifdef __cplusplus +} +#endif + +/* + * pseudo functions + */ +#define wgetstr(w, s) wgetnstr(w, s, -1) + +#define napms(x) usleep(1000*x) +#define setterm(term) setupterm(term, 1, (int *)0) + +#define fixterm() reset_prog_mode() +#define resetterm() reset_shell_mode() +#define saveterm() def_prog_mode() +#define crmode() cbreak() +#define nocrmode() nocbreak() +#define gettmode() + +#define getyx(win,y,x) (y = (win)->_cury, x = (win)->_curx) +#define getbegyx(win,y,x) (y = (win)->_begy, x = (win)->_begx) +#define getmaxyx(win,y,x) (y = (win)->_maxy + 1, x = (win)->_maxx + 1) +#define getsyx(y,x) getyx(stdscr, y, x) +#define setsyx(y,x) (stdscr->_cury = y, stdscr->_curx = x) + +/* It seems older SYSV curses define these */ +#define getattrs(win) (win->_attrs) +#define getmaxx(win) ((win)->_maxx + 1) +#define getmaxy(win) ((win)->_maxy + 1) + +#define winch(win) ((win)->_line[(win)->_cury][(win)->_curx]) +#define wstandout(win) (wattrset(win,A_STANDOUT)) +#define wstandend(win) (wattrset(win,A_NORMAL)) +#define wattroff(win,at) ((win)->_attrs &= ~(at)) +#define wattrset(win,at) ((win)->_attrs = (at)) + +#define subpad(p,l,c,y,x) derwin(p,l,c,y,x) +#define scroll(win) wscrl(win,1) + +#define touchwin(win) wtouchln((win), 0, (win)->_maxy + 1, 1) +#define touchline(win, s, c) wtouchln((win), s, c, 1) +#define untouchwin(win) wtouchln((win), 0, (win)->_maxy + 1, 0) + +#define box(win, v, h) wborder(win, v, v, h, h, 0, 0, 0, 0) +#define border(ls, rs, ts, bs, tl, tr, bl, br) wborder(stdscr, ls, rs, ts, bs, tl, tr, bl, br) +#define hline(ch, n) whline(stdscr, ch, n) +#define vline(ch, n) wvline(stdscr, ch, n) + +#define winsstr(w, s) winsnstr(w, s, 0) + +#define redrawwin(w) redrawln(w, 0, w->_maxy+1) + +/* + * psuedo functions for standard screen + */ + +#define inch() winch(stdscr) +#define standout() wstandout(stdscr) +#define standend() wstandend(stdscr) +#define attron(at) wattron(stdscr,at) +#define attroff(at) wattroff(stdscr,at) +#define attrset(at) wattrset(stdscr,at) +#define addch(ch) waddch(stdscr,ch) +#define getch() wgetch(stdscr) +#define addstr(str) waddnstr(stdscr,str,-1) +#define getstr(str) wgetstr(stdscr,str) +#define move(y, x) wmove(stdscr,y,x) +#define clear() wclear(stdscr) +#define erase() werase(stdscr) +#define clrtobot() wclrtobot(stdscr) +#define clrtoeol() wclrtoeol(stdscr) +#define insertln() winsertln(stdscr) +#define deleteln() wdeleteln(stdscr) +#define refresh() wrefresh(stdscr) +#define insch(c) winsch(stdscr,c) +#define delch() wdelch(stdscr) +#define setscrreg(t,b) wsetscrreg(stdscr,t,b) +#define scrl(n) wscrl(stdscr,n) +#define timeout(delay) wtimeout(stdscr, delay) +#define waddstr(win,str) waddnstr(win,str,-1) +#define waddchstr(win,str) waddchnstr(win,str,-1) +#define addchstr(str) waddchstr(stdscr, str) +#define addchnstr(str, n) waddchnstr(stdscr, str, n) +#define insdel(n) winsdel(stdscr, n) +#define insstr(s) winsstr(stdscr, s) +#define insnstr(s, n) winsnstr(stdscr, s, n) + +/* + * mv functions +*/ + +#define mvwaddch(win,y,x,ch) (wmove(win,y,x) == ERR ? ERR : waddch(win,ch)) +#define mvwgetch(win,y,x) (wmove(win,y,x) == ERR ? ERR : wgetch(win)) +#define mvwaddchnstr(win,y,x,str,n) (wmove(win,y,x) == ERR ? ERR : waddchnstr(win,str,n)) +#define mvwaddchstr(win,y,x,str) (wmove(win,y,x) == ERR ? ERR : waddchnstr(win,str,-1)) +#define mvwaddnstr(win,y,x,str,n) (wmove(win,y,x) == ERR ? ERR : waddnstr(win,str,n)) +#define mvwaddstr(win,y,x,str) (wmove(win,y,x) == ERR ? ERR : waddnstr(win,str,-1)) +#define mvwgetstr(win,y,x,str) (wmove(win,y,x) == ERR ? ERR : wgetstr(win,str)) +#define mvwinch(win,y,x) (wmove(win,y,x) == ERR ? ERR : winch(win)) +#define mvwdelch(win,y,x) (wmove(win,y,x) == ERR ? ERR : wdelch(win)) +#define mvwinsch(win,y,x,c) (wmove(win,y,x) == ERR ? ERR : winsch(win,c)) +#define mvaddch(y,x,ch) mvwaddch(stdscr,y,x,ch) +#define mvgetch(y,x) mvwgetch(stdscr,y,x) +#define mvaddnstr(y,x,str,n) mvwaddnstr(stdscr,y,x,str,n) +#define mvaddstr(y,x,str) mvwaddstr(stdscr,y,x,str) +#define mvgetstr(y,x,str) mvwgetstr(stdscr,y,x,str) +#define mvinch(y,x) mvwinch(stdscr,y,x) +#define mvdelch(y,x) mvwdelch(stdscr,y,x) +#define mvinsch(y,x,c) mvwinsch(stdscr,y,x,c) +#define mvwinsstr(w, y, x, s) (wmove(w,y,x) == ERR ? ERR : winsstr(w,s)) +#define mvwinsnstr(w, y, x, s, n) (wmove(w,y,x) == ERR ? ERR : winsnstr(w,s,n)) +#define mvinsstr(y,x,s) mvwinsstr(stdscr,y,x,s) +#define mvinsnstr(y,x,s,n) mvwinsnstr(stdscr,y,x,s,n) + +/* Funny "characters" enabled for various special function keys for input */ +/* Whether such a key exists depend if its definition is in the terminfo entry */ + +#define KEY_MIN 0401 /* Minimum curses key */ +#define KEY_BREAK 0401 /* break key (unreliable) */ +#define KEY_DOWN 0402 /* The four arrow keys ... */ +#define KEY_UP 0403 +#define KEY_LEFT 0404 +#define KEY_RIGHT 0405 /* ... */ +#define KEY_HOME 0406 /* Home key (upward+left arrow) */ +#define KEY_BACKSPACE 0407 /* backspace (unreliable) */ +#define KEY_F0 0410 /* Function keys. Space for 64 */ +#define KEY_F(n) (KEY_F0+(n)) /* keys is reserved. */ +#define KEY_DL 0510 /* Delete line */ +#define KEY_IL 0511 /* Insert line */ +#define KEY_DC 0512 /* Delete character */ +#define KEY_IC 0513 /* Insert char or enter insert mode */ +#define KEY_EIC 0514 /* Exit insert char mode */ +#define KEY_CLEAR 0515 /* Clear screen */ +#define KEY_EOS 0516 /* Clear to end of screen */ +#define KEY_EOL 0517 /* Clear to end of line */ +#define KEY_SF 0520 /* Scroll 1 line forward */ +#define KEY_SR 0521 /* Scroll 1 line backwards (reverse) */ +#define KEY_NPAGE 0522 /* Next page */ +#define KEY_PPAGE 0523 /* Previous page */ +#define KEY_STAB 0524 /* Set tab */ +#define KEY_CTAB 0525 /* Clear tab */ +#define KEY_CATAB 0526 /* Clear all tabs */ +#define KEY_ENTER 0527 /* Enter or send (unreliable) */ +#define KEY_SRESET 0530 /* soft (partial) reset (unreliable) */ +#define KEY_RESET 0531 /* reset or hard reset (unreliable) */ +#define KEY_PRINT 0532 /* print or copy */ +#define KEY_LL 0533 /* home down or bottom (lower left) */ + +/* The keypad is arranged like this: */ +/* a1 up a3 */ +/* left b2 right */ +/* c1 down c3 */ + +#define KEY_A1 0534 /* Upper left of keypad */ +#define KEY_A3 0535 /* Upper right of keypad */ +#define KEY_B2 0536 /* Center of keypad */ +#define KEY_C1 0537 /* Lower left of keypad */ +#define KEY_C3 0540 /* Lower right of keypad */ +#define KEY_BTAB 0541 /* Back tab key */ +#define KEY_BEG 0542 /* beg(inning) key */ +#define KEY_CANCEL 0543 /* cancel key */ +#define KEY_CLOSE 0544 /* close key */ +#define KEY_COMMAND 0545 /* cmd (command) key */ +#define KEY_COPY 0546 /* copy key */ +#define KEY_CREATE 0547 /* create key */ +#define KEY_END 0550 /* end key */ +#define KEY_EXIT 0551 /* exit key */ +#define KEY_FIND 0552 /* find key */ +#define KEY_HELP 0553 /* help key */ +#define KEY_MARK 0554 /* mark key */ +#define KEY_MESSAGE 0555 /* message key */ +#define KEY_MOVE 0556 /* move key */ +#define KEY_NEXT 0557 /* next object key */ +#define KEY_OPEN 0560 /* open key */ +#define KEY_OPTIONS 0561 /* options key */ +#define KEY_PREVIOUS 0562 /* previous object key */ +#define KEY_REDO 0563 /* redo key */ +#define KEY_REFERENCE 0564 /* ref(erence) key */ +#define KEY_REFRESH 0565 /* refresh key */ +#define KEY_REPLACE 0566 /* replace key */ +#define KEY_RESTART 0567 /* restart key */ +#define KEY_RESUME 0570 /* resume key */ +#define KEY_SAVE 0571 /* save key */ +#define KEY_SBEG 0572 /* shifted beginning key */ +#define KEY_SCANCEL 0573 /* shifted cancel key */ +#define KEY_SCOMMAND 0574 /* shifted command key */ +#define KEY_SCOPY 0575 /* shifted copy key */ +#define KEY_SCREATE 0576 /* shifted create key */ +#define KEY_SDC 0577 /* shifted delete char key */ +#define KEY_SDL 0600 /* shifted delete line key */ +#define KEY_SELECT 0601 /* select key */ +#define KEY_SEND 0602 /* shifted end key */ +#define KEY_SEOL 0603 /* shifted clear line key */ +#define KEY_SEXIT 0604 /* shifted exit key */ +#define KEY_SFIND 0605 /* shifted find key */ +#define KEY_SHELP 0606 /* shifted help key */ +#define KEY_SHOME 0607 /* shifted home key */ +#define KEY_SIC 0610 /* shifted input key */ +#define KEY_SLEFT 0611 /* shifted left arrow key */ +#define KEY_SMESSAGE 0612 /* shifted message key */ +#define KEY_SMOVE 0613 /* shifted move key */ +#define KEY_SNEXT 0614 /* shifted next key */ +#define KEY_SOPTIONS 0615 /* shifted options key */ +#define KEY_SPREVIOUS 0616 /* shifted prev key */ +#define KEY_SPRINT 0617 /* shifted print key */ +#define KEY_SREDO 0620 /* shifted redo key */ +#define KEY_SREPLACE 0621 /* shifted replace key */ +#define KEY_SRIGHT 0622 /* shifted right arrow */ +#define KEY_SRSUME 0623 /* shifted resume key */ +#define KEY_SSAVE 0624 /* shifted save key */ +#define KEY_SSUSPEND 0625 /* shifted suspend key */ +#define KEY_SUNDO 0626 /* shifted undo key */ +#define KEY_SUSPEND 0627 /* suspend key */ +#define KEY_UNDO 0630 /* undo key */ +#define KEY_MAX 0777 /* Maximum curses key */ + +#endif diff --git a/lib/libncurses/nterm.h b/lib/libncurses/nterm.h new file mode 100644 index 000000000000..bcbf31517378 --- /dev/null +++ b/lib/libncurses/nterm.h @@ -0,0 +1,6 @@ +/* libmytinfo must be installed first */ +#include +#define Filedes fd +#define Ottyb shell_mode +#define Nttyb prog_mode +#define TTY struct termios diff --git a/lib/libncurses/term.5 b/lib/libncurses/term.5 new file mode 100644 index 000000000000..68f5d7f1b53c --- /dev/null +++ b/lib/libncurses/term.5 @@ -0,0 +1,153 @@ +.TH TERM 5 +.ds n 5 +.ds d /usr/lib/terminfo +.SH NAME +term \- format of compiled term file. +.SH SYNOPSIS +.B term +.SH DESCRIPTION +.PP +Compiled terminfo descriptions are placed under the directory \fB\*d\fP. +In order to avoid a linear search of a huge \s-1UNIX\s+1 system directory, a +two-level scheme is used: \fB\*b/c/name\fP +where +.I name +is the name of the terminal, and +.I c +is the first character of +.IR name . +Thus, +.I act4 +can be found in the file \fB\*d/a/act4\fP. +Synonyms for the same terminal are implemented by multiple +links to the same compiled file. +.PP +The format has been chosen so that it will be the same on all hardware. +An 8 or more bit byte is assumed, but no assumptions about byte ordering +or sign extension are made. +.PP +The compiled file is created with the +.I tic +program, and read by the routine +.IR setupterm . +Both of these pieces of software are part of +.IR ncurses (3X). +The file is divided into six parts: +the header, +terminal names, +boolean flags, +numbers, +strings, +and +string table. +.PP +The header section begins the file. +This section contains six short integers in the format +described below. +These integers are +(1) the magic number (octal 0432); +(2) the size, in bytes, of the names section; +(3) the number of bytes in the boolean section; +(4) the number of short integers in the numbers section; +(5) the number of offsets (short integers) in the strings section; +(6) the size, in bytes, of the string table. +.PP +Short integers are stored in two 8-bit bytes. +The first byte contains the least significant 8 bits of the value, +and the second byte contains the most significant 8 bits. +(Thus, the value represented is 256*second+first.) +The value \-1 is represented by 0377, 0377, other negative +value are illegal. +The +\-1 generally means that a capability is missing from this terminal. +Note that this format corresponds to the hardware of the \s-1VAX\s+1 and \s-1PDP\s+1-11. +Machines where this does not correspond to the hardware read the +integers as two bytes and compute the result. +.PP +The terminal names section comes next. +It contains the first line of the terminfo description, +listing the various names for the terminal, +separated by the `|' character. +The section is terminated with an \s-1ASCII NUL\s+1 character. +.PP +The boolean flags have one byte for each flag. +This byte is either 0 or 1 as the flag is present or absent. +The capabilities are in the same order as the file . +.PP +Between the boolean section and the number section, +a null byte will be inserted, if necessary, +to ensure that the number section begins on an even byte. +All short integers are aligned on a short word boundary. +.PP +The numbers section is similar to the flags section. +Each capability takes up two bytes, +and is stored as a short integer. +If the value represented is \-1, the capability is taken to be missing. +.PP +The strings section is also similar. +Each capability is stored as a short integer, in the format above. +A value of \-1 means the capability is missing. +Otherwise, the value is taken as an offset from the beginning +of the string table. +Special characters in ^X or \ec notation are stored in their +interpreted form, not the printing representation. +Padding information $ and parameter information %x are +stored intact in uninterpreted form. +.PP +The final section is the string table. +It contains all the values of string capabilities referenced in +the string section. +Each string is null terminated. +.PP +Note that it is possible for +.I setupterm +to expect a different set of capabilities +than are actually present in the file. +Either the database may have been updated since +.I setupterm +has been recompiled +(resulting in extra unrecognized entries in the file) +or the program may have been recompiled more recently +than the database was updated +(resulting in missing entries). +The routine +.I setupterm +must be prepared for both possibilities \- +this is why the numbers and sizes are included. +Also, new capabilities must always be added at the end of the lists +of boolean, number, and string capabilities. +.PP +As an example, an octal dump of the description for the Microterm ACT 4 +is included: +.nf +.sp +microterm|act4|microterm act iv, + cr=^M, cud1=^J, ind=^J, bel=^G, am, cub1=^H, + ed=^_, el=^^, clear=^L, cup=^T%p1%c%p2%c, + cols#80, lines#24, cuf1=^X, cuu1=^Z, home=^], +.sp +.ft CW +\s-2000 032 001 \e0 025 \e0 \eb \e0 212 \e0 " \e0 m i c r +020 o t e r m | a c t 4 | m i c r o +040 t e r m a c t i v \e0 \e0 001 \e0 \e0 +060 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 \e0 +100 \e0 \e0 P \e0 377 377 030 \e0 377 377 377 377 377 377 377 377 +120 377 377 377 377 \e0 \e0 002 \e0 377 377 377 377 004 \e0 006 \e0 +140 \eb \e0 377 377 377 377 \en \e0 026 \e0 030 \e0 377 377 032 \e0 +160 377 377 377 377 034 \e0 377 377 036 \e0 377 377 377 377 377 377 +200 377 377 377 377 377 377 377 377 377 377 377 377 377 377 377 377 +* +520 377 377 377 377 \e0 377 377 377 377 377 377 377 377 377 377 +540 377 377 377 377 377 377 007 \e0 \er \e0 \ef \e0 036 \e0 037 \e0 +560 024 % p 1 % c % p 2 % c \e0 \en \e0 035 \e0 +600 \eb \e0 030 \e0 032 \e0 \en \e0\s+2 +.ft R +.fi +.sp +.PP +Some limitations: total compiled entries cannot exceed 4096 bytes. +The name field cannot exceed 128 bytes. +.SH FILES +\*d/*/* compiled terminal capability data base +.SH "SEE ALSO" +ncurses(3X), terminfo(\*n). diff --git a/lib/libncurses/termcap.h b/lib/libncurses/termcap.h new file mode 100644 index 000000000000..05c86ca7dfe4 --- /dev/null +++ b/lib/libncurses/termcap.h @@ -0,0 +1,32 @@ + + +#ifndef _TERMCAP_H +#define _TERMCAP_H 1 + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#include + +extern char PC; +extern char *UP; +extern char *BC; +extern short ospeed; + +extern int tgetent __P((char *, const char *)); +extern int tgetflag __P((const char *)); +extern int tgetnum __P((const char *)); +extern char *tgetstr __P((const char *, char **)); + +extern int tputs __P((const char *, int, int (*)(int))); + +extern char *tgoto __P((const char *, int, int)); +extern char *tparam __P((const char *, char *, int, ...)); + +#ifdef __cplusplus +} +#endif + +#endif /* _TERMCAP_H */ diff --git a/lib/libncurses/terminfo.5 b/lib/libncurses/terminfo.5 new file mode 100644 index 000000000000..8c774f81f6a4 --- /dev/null +++ b/lib/libncurses/terminfo.5 @@ -0,0 +1,1656 @@ +.\" Note: this must be run through tbl befor nroff +.TH TERMINFO 5 +.ds n 5 +.ds d /usr/lib/terminfo +.SH NAME +terminfo \- terminal capability data base +.SH SYNOPSIS +\*d/*/* +.SH DESCRIPTION +.I Terminfo +is a data base describing terminals, used by screen-oriented programs such as +.IR vi (1), +.IR rogue (1) +and +.IR ncurses (3X). +.I Terminfo +describes terminals by giving a set of capabilities which they +have, by specifying how to perform screen operations, and by +specifying padding requirements and initialization sequences. +.PP +Entries in +.I terminfo +consist of a number of `,' separated fields. +White space after each `,' is ignored. +The first entry for each terminal gives the names which are known for the +terminal, separated by `|' characters. +The first name given is the most common abbreviation for the terminal, +the last name given should be a long name fully identifying the terminal, +and all others are understood as synonyms for the terminal name. +All names but the last should be in lower case and contain no blanks; +the last name may well contain upper case and blanks for readability. +.PP +Terminal names (except for the last, verbose entry) should +be chosen using the following conventions. +The particular piece of hardware making up the terminal should +have a root name chosen, thus ``hp2621''. +This name should not contain hyphens, except that synonyms may +be chosen that do not conflict with other names. +Modes that the hardware can be in, or user preferences, should +be indicated by appending a hyphen and an indicator of the mode. +Thus, a vt100 in 132 column mode would be vt100-w. +The following suffixes should be used where possible: +.TS +center; +l c l +l l l. +\fBSuffix Meaning Example\fP +-w Wide mode (more than 80 columns) vt100-w +-am With auto. margins (usually default) vt100-am +-nam Without automatic margins vt100-nam +-\fIn\fP Number of lines on the screen aaa-60 +-na No arrow keys (leave them in local) c100-na +-\fIn\fPp Number of pages of memory c100-4p +-rv Reverse video c100-rv +.TE +.SH CAPABILITIES +The variable is the name by which the programmer (at the terminfo level) +accesses the capability. +The capname is the short name used in the text of the database, +and is used by a person updating the database. +The i.code is the two letter internal code used in the compiled database, +and always corresponds to the old +.B termcap +capability name. +.P +Capability names have no hard length limit, but an informal limit of 5 +characters has been adopted to keep them short and to allow the tabs in +the source file +.B caps +to line up nicely. +Whenever possible, names are chosen to be the same as or similar to +the ANSI X3.64-1979 standard. Semantics are also intended to match +those of the specification. +.TP +(P) +indicates that padding may be specified +.TP +(G) +indicates that the string is passed through tparm with +parms as given (#\fIi\fP). +.TP +(*) +indicates that padding may be based on the number of +lines affected +.TP +(#\d\fIi\fP\u) +indicates the \fIi\fP\uth\d parameter. + +.TS +center; +c c c c +c c c c +l l l l. +\fBVariable Cap- I. Description\fR +\f3Booleans name Code\fR +\s-1auto_left_margin, bw bw cub1 wraps from column 0 to last + column\s+1 +\s-1auto_right_margin, am am Terminal has automatic margins\s+1 +\s-1back_color_erase, bce ut screen erased with background color\s+1 +\s-1can_change, ccc cc terminal can re-define exiting colors\s+1 +\s-1ceol_standout_glitch, xhp xs Standout not erased by overwriting + (hp)\s+1 +\s-1col_addr_glitch, xhpa YA only positive motion for hpa/mhpa caps\s+1 +\s-1cpi_changes_res, cpix YF changing character pitch changes resolution\s+1 +\s-1cr_cancels_micro_mode, crxm YB using cr turns off micro mode\s+1 +\s-1eat_newline_glitch, xenl xn newline ignored after 80 cols + (Concept)\s+1 +\s-1erase_overstrike, eo eo Can erase overstrikes with a blank\s+1 +\s-1generic_type, gn gn Generic line type (e.g.,, dialup, + switch).\s+1 +\s-1hard_copy, hc hc Hardcopy terminal\s+1 +\s-1hard_cursor, chts HC cursor is hard to see\s+1 +\s-1has_meta_key, km km Has a meta key (shift, sets parity + bit)\s+1 +\s-1has_print_wheel, daisy YC printer needs operator to change character set\s+1 +\s-1has_status_line, hs hs Has extra "status line"\s+1 +\s-1hue_lightness_saturation, hls hl terminal uses only HLS color notation (tektronix)\s+1 +\s-1insert_null_glitch, in in Insert mode distinguishes nulls\s+1 +\s-1lpi_changes_res, lpix YG chnaging line pitch changes resolution\s+1 +\s-1memory_above, da da Display may be retained above the + screen\s+1 +\s-1memory_below, db db Display may be retained below the + screen\s+1 +\s-1move_insert_mode, mir mi Safe to move while in insert mode\s+1 +\s-1move_standout_mode, msgr ms Safe to move in standout modes\s+1 +\s-1needs_xon_xoff, nxon nx padding won't work, xon/xoff required\s+1 +\s-1no_esc_ctl_c, xsb xb Beehive (f1=escape, f2=ctrl C)\s+1 +\s-1non_rev_rmcup, nrrmc NR smcup does not revrse rmcup\s+1 +\s-1no_pad_char, npc NP pad character does not exist\s+1 +\s-1non_dest_scroll_region, ndscr ND scrolling region is non-destructive\s+1 +\s-1over_strike, os os Terminal overstrikes\s+1 +\s-1prtr_silent, mc5i 5i printer won't echo on screen\s+1 +\s-1row_addr_glitch, xvpa YD only posistive motion for vhp/mvpa caps\s+1 +\s-1semi_auto_right_margin, sam YE printing in last column causes cr\s+1 +\s-1status_line_esc_ok, eslok es Escape can be used on the status line\s+1 +\s-1dest_tabs_magic_smso, xt xt Tabs ruin, magic so char (Teleray + 1061)\s+1 +\s-1tilde_glitch, hz hz Hazeltine; can not print ~'s\s+1 +\s-1transparent_underline, ul ul underline character overstrikes\s+1 +\s-1xon_xoff, xon xo Terminal uses xon/xoff handshaking\s+1 + +\s-1\f3Numbers:\fR\s+1 +\s-1bit_image_entwining, bitwin Yo Undocumented in SVr4.0\s+1 +\s-1buffer_capacity, bufsz Ya numbers of bytes buffered before printing\s+1 +\s-1columns, cols co Number of columns in a line\s+1 +\s-1dot_vert_spacing, spinv Yb spacing of dots horizontally in dots per inch\s+1 +\s-1dot_horz_spacing, spinh Yc spacing of pins vertically in pins per inch\s+1 +\s-1init_tabs, it it Tabs initially every # spaces\s+1 +\s-1label_height, lh lh rows in each label\s+1 +\s-1label_width, lw lw columns in each label\s+1 +\s-1lines, lines li Number of lines on screen or page\s+1 +\s-1lines_of_memory, lm lm Lines of memory if > lines. 0 means varies\s+1 +\s-1magic_cookie_glitch, xmc sg Number of blank chars left by smso or rmso\s+1 +\s-1max_colors, colors Co maximum numbers of colors on screen\s+1 +\s-1max_micro_address, maddr Yd maximum value in micro_..._address\s+1 +\s-1max_micro_jump, mjump Ye maximum value in parm_..._micro\s+1 +\s-1max_pairs, pairs pa maximum number of color-pairs on the screen\s+1 +\s-1micro_col_size, mcs Yf Character step size when in micro mode\s+1 +\s-1micro_line_size, mls Yg Line step size when in micro mode\s+1 +\s-1no_color_video, ncv NC video attributes that can't be used with colors\s+1 +\s-1number_of_pins, npins Yh numbers of pins in print-head\s+1 +\s-1num_labels, nlab Nl number of lables on screen\s+1 +\s-1output_res_char, orc Yi horizontal resolution in units per line\s+1 +\s-1output_res_line, orl Yj vertical resolution in units per line\s+1 +\s-1output_res_horz_inch, orhi Yk horizontal resolution in units per inch\s+1 +\s-1output_res_vert_inch, orvi Yl vertical resolution in units per inch\s+1 +\s-1padding_baud_rate, pb pb Lowest baud where cr/nl padding is needed\s+1 +\s-1virtual_terminal, vt vt Virtual terminal number (\s-1UNIX\s+1 system)\s+1 +\s-1width_status_line, wsl ws No. columns in status line\s+1 +.TE + +(The following numeric capabilities are present in the SVr4.0 term structure, +but are not yet documented in the man page. Comments are from the term +structure header.) + +.TS +center; +c c c c +c c c c +l l l l. +\s-1bit_image_type, bitype Yp Type of bit-image device\s+1 +\s-1buttons, btns BT Number of mouse buttons\s+1 +\s-1max_attributes, ma ma Max combined attributes terminal can handle\s+1 +\s-1maximum_windows, wnum MW Max number of defineable windows\s+1 +\s-1print_rate, cps Ym Print rate in chars per second\s+1 +\s-1wide_char_size, widcs Yn Char step size in double wide mode\s+1 + +\s-1\f3Strings:\fR\s+1 +\s-1acs_chars, acsc ac Graphics charset pairs - def=vt100\s+1 +\s-1alt_scancode_esc, scesa S8 Alternate esc for scancode emulation (default is vt100)\s+1 +\s-1back_tab, cbt bt Back tab (P)\s+1 +\s-1bell, bel bl Audible signal (bell) (P)\s+1 +\s-1bit_image_repeat, birep Xy Repeat bit image cell #1 #2 times (use tparm)\s+1 +\s-1bit_image_newline, binel Zz Move to next row of the bit image (use tparm)\s+1 +\s-1bit_image_carriage_return, bicr Yv Move to beginning of same row (use tparm)\s+1 +\s-1carriage_return, cr cr Carriage return (P*)\s+1 +\s-1change_char_pitch, cpi ZA Change # chars per inch\s+1 +\s-1change_line_pitch, lpi ZB Change # lines per inch\s+1 +\s-1change_res_horz, chr ZC Change horizontal resolution\s+1 +\s-1change_res_vert, cvr ZD Change vertical resolution\s+1 +\s-1change_scroll_region, csr cs Change to lines #1 through #2 (vt100) (PG)\s+1 +\s-1char_padding, rmp rP Like ip but when in insert mode\s+1 +\s-1char_set_names, csnm Zy List of character set names\s+1 +\s-1clear_all_tabs, tbc ct Clear all tab stops (P)\s+1 +\s-1clear_margins, mgc MC Clear all margins (top, bottom, and sides)\s+1 +\s-1clear_screen, clear cl Clear screen and home cursor (P*)\s+1 +\s-1clr_bol. el1 cb Clear to beginning of line\s+1 +\s-1clr_eol, el ce Clear to end of line (P)\s+1 +\s-1clr_eos, ed cd Clear to end of display (P*)\s+1 +\s-1code_set_init, csin ci Init sequence for multiple code sets\s+1 +\s-1color_names, colornm Yw Give name for color #1\s+1 +\s-1column_address, hpa ch Set cursor column (PG)\s+1 +\s-1command_character, cmdch CC Term. settable cmd char in prototype\s+1 +\s-1cursor_address, cup cm Screen rel. cursor motion row #1 + col #2 (PG)\s+1 +\s-1cursor_down, cud1 do Down one line\s+1 +\s-1cursor_home, home ho Home cursor (if no cup)\s+1 +\s-1cursor_invisible, civis vi Make cursor invisible\s+1 +\s-1cursor_left, cub1 le Move cursor left one space\s+1 +\s-1cursor_mem_address, mrcup CM Memory relative cursor addressing\s+1 +\s-1cursor_normal, cnorm ve Make cursor appear normal (undo vs/vi)\s+1 +\s-1cursor_right, cuf1 nd Non-destructive space (cursor right)\s+1 +\s-1cursor_to_ll, ll ll Last line, first column (if no cup)\s+1 +\s-1cursor_up, cuu1 up Upline (cursor up)\s+1 +\s-1cursor_visible, cvvis vs Make cursor very visible\s+1 +\s-1define_bit_image_region, defbi Yx Define rectangular bit image region (use tparm)\s+1 +\s-1define_char, defc ZE Define character in a character set\s+1 +\s-1delete_character, dch1 dc Delete character (P*)\s+1 +\s-1delete_line, dl1 dl Delete line (P*)\s+1 +\s-1device_type, devt dv Indicate language/codeset support\s+1 +\s-1dis_status_line, dsl ds Disable status line\s+1 +\s-1display_pc_char, dispc S1 Display PC character\s+1 +\s-1down_half_line, hd hd Half-line down (forward 1/2 linefeed)\s+1 +\s-1ena_acs, enacs eA enable alternate char set\s+1 +\s-1end_bit_image_region, endbi Yy End bit image region (use tparm)\s+1 +\s-1enter_alt_charset_mode, smacs as Start alternate character set (P)\s+1 +\s-1enter_am_mode, smam SA turn on automatic margins\s+1 +\s-1enter_blink_mode, blink mb Turn on blinking\s+1 +\s-1enter_bold_mode, bold md Turn on bold (extra bright) mode\s+1 +\s-1enter_ca_mode, smcup ti String to begin programs that use cup\s+1 +\s-1enter_delete_mode, smdc dm Delete mode (enter)\s+1 +\s-1enter_dim_mode, dim mh Turn on half-bright mode\s+1 +\s-1enter_doublewide_mode, swidm ZF Enable double-wide mode\s+1 +\s-1enter_draft_quality, sdrfq ZG Set draft-quality printing\s+1 +\s-1enter_insert_mode, smir im Insert mode (enter);\s+1 +\s-1enter_italics_mode, sitm ZH Enable italics mode\s+1 +\s-1enter_leftward_mode, slm ZI Enable leftward carriage motion\s+1 +\s-1enter_micro_mode, smicm ZJ Enable micro-motion capabilities\s+1 +\s-1enter_near_letter_quality, snlq ZK Set NLQ printing\s+1 +\s-1enter_normal_quality, snrmq ZL Set normal quality printing\s+1 +\s-1enter_pc_charset_mode, smpch S2 Enter PC character display mode\s+1 +\s-1enter_protected_mode, prot mp Turn on protected mode\s+1 +\s-1enter_reverse_mode, rev mr Turn on reverse video mode\s+1 +\s-1enter_scancode_mode, smsc S4 Enter PC scancode mode\s+1 +\s-1enter_secure_mode, invis mk Turn on blank mode (chars invisible)\s+1 +\s-1enter_shadow_mode, sshm ZM Enable shadow-mode printing\s+1 +\s-1enter_standout_mode, smso so Begin stand out mode\s+1 +\s-1enter_subscript_mode, ssubm ZN Enable subscript printing\s+1 +\s-1enter_superscript_mode, ssupm ZO Enable supercript printing\s+1 +\s-1enter_underline_mode, smul us Start underscore mode\s+1 +\s-1enter_upward_mode, sum ZP Enable upward carriage motion\s+1 +\s-1enter_xon_mode, smxon SX Turn on xon/xoff handshaking\s+1 +\s-1erase_chars, ech ec Erase #1 characters (PG)\s+1 +\s-1exit_alt_charset_mode, rmacs ae End alternate character set (P)\s+1 +\s-1exit_am_mode, rmam RA Turn off automatic margins\s+1 +\s-1exit_attribute_mode, sgr0 me Turn off all attributes\s+1 +\s-1exit_ca_mode, rmcup te String to end programs that use cup\s+1 +\s-1exit_delete_mode, rmdc ed End delete mode\s+1 +\s-1exit_doublewide_mode, rwidm ZQ Disable doublewide printing\s+1 +\s-1exit_insert_mode, rmir ei End insert mode\s+1 +\s-1exit_italics_mode, ritm ZR Disable italic printing\s+1 +\s-1exit_leftward_mode, rlm ZS Enable rightward (normal) carriage motion\s+1 +\s-1exit_micro_mode, rmicm ZT Disable micro motion capabilities\s+1 +\s-1exit_pc_charset_mode, rmpch S3 Disable PC character display\s+1 +\s-1exit_scancode_mode, rmsc S5 Disable PC scancode mode\s+1 +\s-1exit_shadow_mode, rshm ZU Disable shadow printing\s+1 +\s-1exit_standout_mode, rmso se End stand out mode\s+1 +\s-1exit_subscript_mode, rsubm ZV Disable subscript printing\s+1 +\s-1exit_superscript_mode, rsupm ZW Disable supercript printing\s+1 +\s-1exit_underline_mode, rmul ue End underscore mode\s+1 +\s-1exit_upward_mode, rum ZX Enable downward (normal) carriage motion\s+1 +\s-1exit_xon_mode, rmxon RX turn off xon/xoff handshaking\s+1 +\s-1flash_screen, flash vb Visible bell (may not move cursor)\s+1 +\s-1form_feed, ff ff Hardcopy terminal page eject (P*)\s+1 +\s-1from_status_line, fsl fs Return from status line\s+1 +\s-1init_1string, is1 i1 Terminal initialization string\s+1 +\s-1init_2string, is2 i2 Terminal initialization string\s+1 +\s-1init_3string, is3 i3 Terminal initialization string\s+1 +\s-1init_file, if if Name of file containing is\s+1 +\s-1init_prog, iprog iP Path name of program for init\s+1 +\s-1initialize_color, initc Ic Initialize the definition of color\s+1 +\s-1initialize_pair, initp Ip Initialize color-pair\s+1 +\s-1insert_character, ich1 ic Insert character (P)\s+1 +\s-1insert_line, il1 al Add new blank line (P*)\s+1 +\s-1insert_padding, ip ip Insert pad after character inserted + (p*)\s+1 +\s-1key_a1, ka1 K1 Upper left of keypad\s+1 +\s-1key_a3, ka3 K3 Upper right of keypad\s+1 +\s-1key_b2, kb2 K2 Center of keypad\s+1 +\s-1key_backspace, kbs kb Sent by backspace key\s+1 +\s-1key_beg, kbeg @1 begin key\s+1 +\s-1key_btab, kcbt kB back-tab key\s+1 +\s-1key_c1, kc1 K4 Lower left of keypad\s+1 +\s-1key_c3, kc3 K5 Lower right of keypad\s+1 +\s-1key_cancel, kcan @2 cancel key\s+1 +\s-1key_catab, ktbc ka Sent by clear-all-tabs key\s+1 +\s-1key_clear, kclr kC Sent by clear screen or erase key\s+1 +\s-1key_close, kclo @3 close key\s+1 +\s-1key_command, kcmd @4 command key\s+1 +\s-1key_copy, kcpy @5 copy key\s+1 +\s-1key_create, kcrt @6 create key\s+1 +\s-1key_ctab, kctab kt Sent by clear-tab key\s+1 +\s-1key_dc, kdch1 kD Sent by delete character key\s+1 +\s-1key_dl, kdl1 kL Sent by delete line key\s+1 +\s-1key_down, kcud1 kd Sent by terminal down arrow key\s+1 +\s-1key_eic, krmir kM Sent by rmir or smir in insert mode\s+1 +\s-1key_end, kend @7 end key\s+1 +\s-1key_enter, kent @8 enter/send key\s+1 +\s-1key_eol, kel kE Sent by clear-to-end-of-line key\s+1 +\s-1key_eos, ked kS Sent by clear-to-end-of-screen key\s+1 +\s-1key_exit, kext @9 exit key\s+1 +\s-1key_f0, kf0 k0 Sent by function key f0\s+1 +\s-1key_f1, kf1 k1 Sent by function key f1\s+1 +\s-1key_f2, kf2 k2 Sent by function key f2\s+1 +\s-1key_f3, kf3 k3 Sent by function key f3\s+1 +\s-1key_f4, kf4 k4 Sent by function key f4\s+1 +\s-1key_f5, kf5 k5 Sent by function key f5\s+1 +\s-1key_f6, kf6 k6 Sent by function key f6\s+1 +\s-1key_f7, kf7 k7 Sent by function key f7\s+1 +\s-1key_f8, kf8 k8 Sent by function key f8\s+1 +\s-1key_f9, kf9 k9 Sent by function key f9\s+1 +\s-1key_f10, kf10 k; Sent by function key f10\s+1 +\s-1key_f11, kf11 F1 F11 function key\s+1 +\s-1key_f12, kf12 F2 F12 function key\s+1 +\s-1key_f13, kf13 F3 F13 function key\s+1 +\s-1key_f14, kf14 F4 F14 function key\s+1 +\s-1key_f15, kf15 F5 F15 function key\s+1 +\s-1key_f16, kf16 F6 F16 function key\s+1 +\s-1key_f17, kf17 F7 F17 function key\s+1 +\s-1key_f18, kf18 F8 F18 function key\s+1 +\s-1key_f19, kf19 F9 F19 function key\s+1 +\s-1key_f20, kf20 FA F20 function key\s+1 +\s-1key_f21, kf21 FB F21 function key\s+1 +\s-1key_f22, kf22 FC F22 function key\s+1 +\s-1key_f23, kf23 FD F23 function key\s+1 +\s-1key_f24, kf24 FE F24 function key\s+1 +\s-1key_f25, kf25 FF F25 function key\s+1 +\s-1key_f26, kf26 FG F26 function key\s+1 +\s-1key_f27, kf27 FH F27 function key\s+1 +\s-1key_f28, kf28 FI F28 function key\s+1 +\s-1key_f29, kf29 FJ F29 function key\s+1 +\s-1key_f30, kf30 FK F30 function key\s+1 +\s-1key_f31, kf31 FL F31 function key\s+1 +\s-1key_f32, kf32 FM F32 function key\s+1 +\s-1key_f33, kf33 FN F33 function key\s+1 +\s-1key_f34, kf34 FO F34 function key\s+1 +\s-1key_f35, kf35 FP F35 function key\s+1 +\s-1key_f36, kf36 FQ F36 function key\s+1 +\s-1key_f37, kf37 FR F37 function key\s+1 +\s-1key_f38, kf38 FS F38 function key\s+1 +\s-1key_f39, kf39 FT F39 function key\s+1 +\s-1key_f40, kf40 FU F40 function key\s+1 +\s-1key_f41, kf41 FV F41 function key\s+1 +\s-1key_f42, kf42 FW F42 function key\s+1 +\s-1key_f43, kf43 FX F43 function key\s+1 +\s-1key_f44, kf44 FY F44 function key\s+1 +\s-1key_f45, kf45 FZ F45 function key\s+1 +\s-1key_f46, kf46 Fa F46 function key\s+1 +\s-1key_f47, kf47 Fb F47 function key\s+1 +\s-1key_f48, kf48 Fc F48 function key\s+1 +\s-1key_f49, kf49 Fd F49 function key\s+1 +\s-1key_f50, kf50 Fe F50 function key\s+1 +\s-1key_f51, kf51 Ff F51 function key\s+1 +\s-1key_f52, kf52 Fg F52 function key\s+1 +\s-1key_f53, kf53 Fh F53 function key\s+1 +\s-1key_f54, kf54 Fi F54 function key\s+1 +\s-1key_f55, kf55 Fj F55 function key\s+1 +\s-1key_f56, kf56 Fk F56 function key\s+1 +\s-1key_f57, kf57 Fl F57 function key\s+1 +\s-1key_f58, kf58 Fm F58 function key\s+1 +\s-1key_f59, kf59 Fn F59 function key\s+1 +\s-1key_f60, kf60 Fo F60 function key\s+1 +\s-1key_f61, kf61 Fp F61 function key\s+1 +\s-1key_f62, kf62 Fq F62 function key\s+1 +\s-1key_f63, kf63 Fr F63 function key\s+1 +\s-1key_find, kfnd @0 find key\s+1 +\s-1key_help, khlp %1 help key\s+1 +\s-1key_home, khome kh Sent by home key\s+1 +\s-1key_ic, kich1 kI Sent by ins char/enter ins mode key\s+1 +\s-1key_il, kil1 kA Sent by insert line\s+1 +\s-1key_left, kcub1 kl Sent by terminal left arrow key\s+1 +\s-1key_ll, kll kH Sent by home-down key\s+1 +\s-1key_mark, kmrk %2 mark key\s+1 +\s-1key_message, kmsg %3 message key\s+1 +\s-1key_move, kmov %4 move key\s+1 +\s-1key_next, knxt %5 next key\s+1 +\s-1key_npage, knp kN Sent by next-page key\s+1 +\s-1key_open, kopn %6 open key\s+1 +\s-1key_options, kopt %7 options key\s+1 +\s-1key_ppage, kpp kP Sent by previous-page key\s+1 +\s-1key_previous, kprv %8 previous key\s+1 +\s-1key_print, kprt %9 print key\s+1 +\s-1key_redo, krdo %0 redo key\s+1 +\s-1key_reference, kref &1 reference key\s+1 +\s-1key_refresh, krfr &2 refresh key\s+1 +\s-1key_replace, krpl &3 replace key\s+1 +\s-1key_restart, krst &4 restart key\s+1 +\s-1key_resume, kres &5 resume key\s+1 +\s-1key_right, kcuf1 kr Sent by terminal right arrow key\s+1 +\s-1key_save, ksav &6 save key\s+1 +\s-1key_sbeg, kBEG &9 shifted begin key\s+1 +\s-1key_scancel, kCAN &0 shifted cancel key\s+1 +\s-1key_scommand, kCMD *1 shifted command key\s+1 +\s-1key_scopy, kCPY *2 shifted copy key\s+1 +\s-1key_screate, kCRT *3 shifted create key\s+1 +\s-1key_sdc, kDC *4 shifted delete char key\s+1 +\s-1key_sdl, kDL *5 shifted delete line key\s+1 +\s-1key_select, kslt *6 select key\s+1 +\s-1key_send, kEND *7 shifted end key\s+1 +\s-1key_seol, kEOL *8 shifted end of line key\s+1 +\s-1key_sexit, kEXT *9 shifted exit key\s+1 +\s-1key_sf, kind kF Sent by scroll-forward/down key\s+1 +\s-1key_sfind, kFND *0 shifted find key\s+1 +\s-1key_shelp, kHLP #1 shifted help key\s+1 +\s-1key_shome, kHOM #2 shifted home key\s+1 +\s-1key_sic, kIC #3 shifted insert char key\s+1 +\s-1key_sleft, kLFT #4 shifted left key\s+1 +\s-1key_smessage, kMSG %a shifted message key\s+1 +\s-1key_smove, kMOV %b shifted move key\s+1 +\s-1key_snext, kNXT %c shifted next key\s+1 +\s-1key_soptions, kOPT %d shifted options key\s+1 +\s-1key_sprevious, kPRV %e shifted previous key\s+1 +\s-1key_sprint, kPRT %f shifted print key\s+1 +\s-1key_sr, kri kR Sent by scroll-backward/up key\s+1 +\s-1key_sredo, kRDO %g shifted redo key\s+1 +\s-1key_sreplace, kRPL %h shifted replace key\s+1 +\s-1key_sright, kRIT %i shifted right key\s+1 +\s-1key_srsume, kRES %j shifted resume key\s+1 +\s-1key_ssave, kSAV !1 shifted save key\s+1 +\s-1key_ssuspend, kSPD !2 shifted suspend key\s+1 +\s-1key_stab, khts kT Sent by set-tab key\s+1 +\s-1key_sundo, kUND !3 shifted undo key\s+1 +\s-1key_suspend, kspd &7 suspend key\s+1 +\s-1key_undo, kund &8 undo key\s+1 +\s-1key_up, kcuu1 ku Sent by terminal up arrow key\s+1 +\s-1keypad_local, rmkx ke Out of "keypad transmit" mode\s+1 +\s-1keypad_xmit, smkx ks Put terminal in "keypad transmit" mode\s+1 +\s-1lab_f0, lf0 l0 Labels on function key f0 if not f0\s+1 +\s-1lab_f1, lf1 l1 Labels on function key f1 if not f1\s+1 +\s-1lab_f2, lf2 l2 Labels on function key f2 if not f2\s+1 +\s-1lab_f3, lf3 l3 Labels on function key f3 if not f3\s+1 +\s-1lab_f4, lf4 l4 Labels on function key f4 if not f4\s+1 +\s-1lab_f5, lf5 l5 Labels on function key f5 if not f5\s+1 +\s-1lab_f6, lf6 l6 Labels on function key f6 if not f6\s+1 +\s-1lab_f7, lf7 l7 Labels on function key f7 if not f7\s+1 +\s-1lab_f8, lf8 l8 Labels on function key f8 if not f8\s+1 +\s-1lab_f9, lf9 l9 Labels on function key f9 if not f9\s+1 +\s-1lab_f10, lf10 la Labels on function key f10 if not f10\s+1 +\s-1label_on, smln LO turn on soft labels\s+1 +\s-1label_off, rmln LF turn off soft labels\s+1 +\s-1meta_off, rmm mo Turn off "meta mode"\s+1 +\s-1meta_on, smm mm Turn on "meta mode" (8th bit)\s+1 +\s-1micro_column_address, mhpa ZY Like column_address for micro adjustment\s+1 +\s-1micro_down, mcud1 ZZ Like cursor_down for micro adjustment\s+1 +\s-1micro_left, mcub1 Za Like cursor_left for micro adjustment\s+1 +\s-1micro_right, mcuf1 Zb Like cursor_right for micro adjustment\s+1 +\s-1micro_row_address, mvpa Zc Like row_address for micro adjustment\s+1 +\s-1micro_up, mcuu1 Zd Like cursor_up for micro adjustment\s+1 +\s-1newline, nel nw Newline (behaves like cr followed by lf)\s+1 +\s-1order_of_pins, porder Ze Matches software buts to print-head pins\s+1 +\s-1orig_colors, oc oc Reset all color pairs\s+1 +\s-1orig_pair, op op Set default color-pair to original one\s+1 +\s-1pad_char, pad pc Pad character (rather than null)\s+1 +\s-1parm_dch, dch DC Delete #1 chars (PG*)\s+1 +\s-1parm_delete_line, dl DL Delete #1 lines (PG*)\s+1 +\s-1parm_down_cursor, cud DO Move cursor down #1 lines (PG*)\s+1 +\s-1parm_down_micro, mcud Zf Like cud for micro adjust\s+1 +\s-1parm_ich, ich IC Insert #1 blank chars (PG*)\s+1 +\s-1parm_index, indn SF Scroll forward #1 lines (PG)\s+1 +\s-1parm_insert_line, il AL Add #1 new blank lines (PG*)\s+1 +\s-1parm_left_cursor, cub LE Move cursor left #1 spaces (PG)\s+1 +\s-1parm_left_micro, mcub Zg Like cul for micro adjust\s+1 +\s-1parm_right_cursor, cuf RI Move cursor right #1 spaces (PG*)\s+1 +\s-1parm_right_micro, mcuf Zh Likr cuf for micro adjust\s+1 +\s-1parm_rindex, rin SR Scroll backward #1 lines (PG)\s+1 +\s-1parm_up_cursor, cuu UP Move cursor up #1 lines (PG*)\s+1 +\s-1parm_up_micro, mcuu Zi Like cuu for micro adjust\s+1 +\s-1pkey_key, pfkey pk Prog funct key #1 to type string #2\s+1 +\s-1pkey_local, pfloc pl Prog funct key #1 to execute string #2\s+1 +\s-1pkey_xmit, pfx px Prog funct key #1 to xmit string #2\s+1 +\s-1pkey_plab, pfxl xl Program key #1 to xmit #2 and show #3\s+1 +\s-1plab_norm, pln pn program label #1 to show string #2\s+1 +\s-1print_screen, mc0 ps Print contents of the screen\s+1 +\s-1prtr_non, mc5p pO Turn on the printer for #1 bytes\s+1 +\s-1prtr_off, mc4 pf Turn off the printer\s+1 +\s-1prtr_on, mc5 po Turn on the printer\s+1 +\s-1repeat_char, rep rp Repeat char #1 #2 times. (PG*)\s+1 +\s-1req_for_input, rfi RF request for input\s+1 +\s-1reset_1string, rs1 r1 Reset terminal completely to sane modes.\s+1 +\s-1reset_2string, rs2 r2 Reset terminal completely to sane modes.\s+1 +\s-1reset_3string, rs3 r3 Reset terminal completely to sane modes.\s+1 +\s-1reset_file, rf rf Name of file containing reset string\s+1 +\s-1restore_cursor, rc rc Restore cursor to position of last sc\s+1 +\s-1row_address, vpa cv Vertical position absolute (set row) (PG)\s+1 +\s-1save_cursor, sc sc Save cursor position (P)\s+1 +\s-1scancode_escape, scesc S7 Escape for scancode emulation\s+1 +\s-1scroll_forward, ind sf Scroll text up (P)\s+1 +\s-1scroll_reverse, ri sr Scroll text down (P)\s+1 +\s-1select_char_set, scs Zj Select character set\s+1 +\s-1set0_des_seq, s0ds s0 Shift to codeset 0 (EUC set 0, ASCII)\s+1 +\s-1set1_des_seq, s1ds s1 Shift to codeset 1\s+1 +\s-1set2_des_seq, s2ds s2 Shift to codeset 2\s+1 +\s-1set3_des_seq, s3ds s3 Shift to codeset 3\s+1 +\s-1set_a_background, setab AB Set background color using ANSI escape\s+1 +\s-1set_a_foreground, setaf AF Set foreground color using ANSI escape\s+1 +\s-1set_attributes, sgr sa Define the video attributes (PG9)\s+1 +\s-1set_background, setb Sb Set current background color\s+1 +\s-1set_bottom_margin, smgb Zk Set bottom margin at current line\s+1 +\s-1set_bottom_margin_parm, smgbp Zl Set bottom line at line #1 or #2 lines from bottom\s+1 +\s-1set_color_band, setcolor Yz Change to ribbon color #1\s+1 +\s-1set_color_pair, scp sp Set current color pair\s+1 +\s-1set_foreground, setf Sf Set current foreground color\s+1 +\s-1set_left_margin, smgl ML Set left margin at current line\s+1 +\s-1set_left_margin_parm, smglp Zm Set left (right) margin at #1 (#2)\s+1 +\s-1set_lr_margin, smglr ML Set both left and right margins\s+1 +\s-1set_page_length, slines YZ Set page length to #1 lines (use tparm)\s+1 +\s-1set_right_margin, smgr MR Set right margin at current column\s+1 +\s-1set_right_margin_parm, smgrp Zn Set right margin at column #1\s+1 +\s-1set_tab, hts st Set a tab in all rows, current column\s+1 +\s-1set_tb_margin, smgtb MT Sets both top and bottom margins\s+1 +\s-1set_top_margin, smgt Zo Set top margin at current line\s+1 +\s-1set_top_margin_parm, smgtp Zp Set top margin at line #1\s+1 +\s-1set_window, wind wi Current window is lines #1-#2 cols #3-#4\s+1 +\s-1start_bit_image, sbim Zq Start printing bit image graphics\s+1 +\s-1start_char_set_def, scsd Zr Start definition of a character set\s+1 +\s-1stop_bit_image, rbim Zs End printing bit image graphics\s+1 +\s-1stop_char_set_def, rcsd Zt End definition of character set\s+1 +\s-1subscript_characters, subcs Zu List of subscriptable chars\s+1 +\s-1superscript_characters, supcs Zv List of superscriptable chars\s+1 +\s-1tab, ht ta Tab to next 8 space hardware tab stop\s+1 +\s-1these_cause_cr, docr Zw These characters cause a CR\s+1 +\s-1to_status_line, tsl ts Go to status line, column #1\s+1 +\s-1underline_char, uc uc Underscore one char and move past it\s+1 +\s-1up_half_line, hu hu Half-line up (reverse 1/2 linefeed)\s+1 +\s-1xoff_character, xoffc XF XON character\s+1 +\s-1xon_character, xonc XN XOFF character\s+1 +.TE + +(The following string capabilities are present in the SVr4.0 term structure, +but are not documented in the man page. Comments are from the term +structure header.) + +.TS +center; +c c c c +c c c c +l l l l. +\s-1label_format, fln Lf ??\s+1 +\s-1set_clock, sclk SC Set time-of-day clock\s+1 +\s-1display_clock, dclk DK Display time-of-day clock\s+1 +\s-1remove_clock, rmclk RC Remove time-of-day clock??\s+1 +\s-1create_window, cwin CW Define win #1 to go from #2,#3 to #4,#5\s+1 +\s-1goto_window, wingo WG Goto window #1\s+1 +\s-1hangup, hup HU Hang up phone\s+1 +\s-1dial_phone, dial DI Dial phone number #1\s+1 +\s-1quick_dial, qdial QD Dial phone number #1, without progress detection\s+1 +\s-1tone, tone TO Select touch tone dialing\s+1 +\s-1pulse, pulse PU Select pulse dialing\s+1 +\s-1flash_hook, hook fh Flash the switch hook\s+1 +\s-1fixed_pause, pause PA Pause for 2-3 seconds\s+1 +\s-1wait_tone, wait WA Wait for dial tone\s+1 +\s-1user0, u0 u0 User string # 0\s+1 +\s-1user1, u1 u1 User string # 1\s+1 +\s-1user2, u2 u2 User string # 2\s+1 +\s-1user3, u3 u3 User string # 3\s+1 +\s-1user4, u4 u4 User string # 4\s+1 +\s-1user5, u5 u5 User string # 5\s+1 +\s-1user6, u6 u6 User string # 6\s+1 +\s-1user7, u7 u7 User string # 7\s+1 +\s-1user8, u8 u8 User string # 8\s+1 +\s-1user9, u9 u9 User string # 9\s+1 +\s-1get_mouse, getm Gm Curses should get button events\s+1 +\s-1key_mouse, kmous Km ??\s+1 +\s-1mouse_info, minfo Mi Mouse status information\s+1 +\s-1pc_term_options, pctrm S6 PC terminal options\s+1 +\s-1req_mouse_pos, reqmp RQ Request mouse position report\s+1 +\s-1zero_motion, zerom, Zx No motion for the subsequent character\s+1 +.TE +.PP +.B A Sample Entry +.PP +The following entry, which describes the Concept\-100, is among the more +complex entries in the +.I terminfo +file as of this writing. +.PP +.nf +.in -2 +.ta .3i +.ft CW +\s-2concept100\||\|c100|\|\|concept\||\|c104\||\|c100-4p\||\|concept 100, + am, bel=^G, blank=\eEH, blink=\eEC, clear=^L$<2*>, cnorm=\eEw, + cols#80, cr=^M$<9>, cub1=^H, cud1=^J, cuf1=\eE=, + cup=\eEa%p1%' '%+%c%p2%' '%+%c, + cuu1=\eE;, cvvis=\eEW, db, dch1=\eE^A$<16*>, dim=\eEE, dl1=\eE^B$<3*>, + ed=\eE^C$<16*>, el=\eE^U$<16>, eo, flash=\eEk$<20>\eEK, ht=\et$<8>, + il1=\eE^R$<3*>, in, ind=^J, .ind=^J$<9>, ip=$<16*>, + is2=\eEU\eEf\eE7\eE5\eE8\eEl\eENH\eEK\eE\e200\eEo&\e200\eEo\e47\eE, + kbs=^h, kcub1=\eE>, kcud1=\eE<, kcuf1=\eE=, kcuu1=\eE;, + kf1=\eE5, kf2=\eE6, kf3=\eE7, khome=\eE?, + lines#24, mir, pb#9600, prot=\eEI, rep=\eEr%p1%c%p2%' '%+%c$<.2*>, + rev=\eED, rmcup=\eEv $<6>\eEp\er\en, rmir=\eE\e200, rmkx=\eEx, + rmso=\eEd\eEe, rmul=\eEg, rmul=\eEg, sgr0=\eEN\e200, + smcup=\eEU\eEv 8p\eEp\er, smir=\eE^P, smkx=\eEX, smso=\eEE\eED, + smul=\eEG, tabs, ul, vt#8, xenl,\s+2 +.in +2 +.fi +.ft R +.PP +Entries may continue onto multiple lines by placing white space at +the beginning of each line except the first. +Comments may be included on lines beginning with ``#''. +Capabilities in +.I terminfo +are of three types: +Boolean capabilities which indicate that the terminal has +some particular feature, numeric capabilities giving the size of the terminal +or the size of particular delays, and string +capabilities, which give a sequence which can be used to perform particular +terminal operations. +.PP +.B Types of Capabilities +.PP +All capabilities have names. For instance, the fact that +the Concept has +.I "automatic margins" +(i.e., an automatic return and linefeed +when the end of a line is reached) is indicated by the capability \fBam\fR. +Hence the description of the Concept includes \fBam\fR. +Numeric capabilities are followed by the character `#' and then the value. +Thus \fBcols\fR, which indicates the number of columns the terminal has, +gives the value `80' for the Concept. +.PP +Finally, string valued capabilities, such as \fBel\fR (clear to end of line +sequence) are given by the two-character code, an `=', and then a string +ending at the next following `,'. A delay in milliseconds may appear +anywhere in such a capability, enclosed in $<..> brackets, +as in \fBel\fP=\eEK$<3>, +and padding characters are supplied by +.I tputs +to provide this delay. +The delay can be either a number, e.g., `20', or a number followed by +an `*', i.e., `3*'. A `*' indicates that the padding required is proportional +to the number of lines affected by the operation, and the amount given is +the per-affected-unit padding required. +(In the case of insert character, the factor is still the number of +.IR lines +affected. +This is always one unless the terminal has \fBxenl\fP and the software uses it.) +When a `*' is specified, it is sometimes useful to give a delay of the form +`3.5' to specify a delay per unit to tenths of milliseconds. +(Only one decimal place is allowed.) +.PP +A number of escape sequences are provided in the string valued capabilities +for easy encoding of characters there. Both \fB\eE\fR and \fB\ee\fR +map to an \s-1ESCAPE\s0 character, +\fB^x\fR maps to a control-x for any appropriate x, and the sequences +\fB\en \el \er \et \eb \ef \es\fR give +a newline, linefeed, return, tab, backspace, formfeed, and space. +Other escapes include \e^ for ^, \e\e for \e, \e, for comma, \e: for :, +and \e0 for null. +(\e0 will produce \e200, which does not terminate a string but behaves +as a null character on most terminals.) +Finally, characters may be given as three octal digits after a \fB\e\fR. +.PP +Sometimes individual capabilities must be commented out. +To do this, put a period before the capability name. +For example, see the second +.B ind +in the example above. +.br +.ne 5 +.PP +.B Preparing Descriptions +.PP +We now outline how to prepare descriptions of terminals. +The most effective way to prepare a terminal description is by imitating +the description of a similar terminal in +.I terminfo +and to build up a description gradually, using partial descriptions +with +.I vi +or some other screen-oriented program to check that they are correct. +Be aware that a very unusual terminal may expose deficiencies in +the ability of the +.I terminfo +file to describe it +or bugs in the screen-handling code of the test program. +To easily test a new terminal description you can set the environment variable +TERMINFO to a pathname of a directory containing the +compiled description you are working +on and programs will look there rather than in +.IR \*d . +To get the padding for insert line right (if the terminal manufacturer +did not document it) a severe test is to edit /etc/passwd at 9600 baud, +delete 16 or so lines from the middle of the screen, then hit the `u' +key several times quickly. +If the terminal messes up, more padding is usually needed. +A similar test can be used for insert character. +.PP +.B Basic Capabilities +.PP +The number of columns on each line for the terminal is given by the +\fBcols\fR numeric capability. If the terminal is a \s-1CRT\s0, then the +number of lines on the screen is given by the \fBlines\fR capability. +If the terminal wraps around to the beginning of the next line when +it reaches the right margin, then it should have the \fBam\fR capability. +If the terminal can clear its screen, leaving the cursor in the home +position, then this is given by the \fBclear\fR string capability. +If the terminal overstrikes +(rather than clearing a position when a character is struck over) +then it should have the \fBos\fR capability. +If the terminal is a printing terminal, with no soft copy unit, +give it both +.B hc +and +.BR os . +.RB ( os +applies to storage scope terminals, such as \s-1TEKTRONIX\s+1 4010 +series, as well as hard copy and APL terminals.) +If there is a code to move the cursor to the left edge of the current +row, give this as +.BR cr . +(Normally this will be carriage return, control M.) +If there is a code to produce an audible signal (bell, beep, etc) +give this as +.BR bel . +.PP +If there is a code to move the cursor one position to the left +(such as backspace) that capability should be given as +.BR cub1 . +Similarly, codes to move to the right, up, and down should be +given as +.BR cuf1 , +.BR cuu1 , +and +.BR cud1 . +These local cursor motions should not alter the text they pass over, +for example, you would not normally use `\fBcuf1\fP=\ ' because the +space would erase the character moved over. +.PP +A very important point here is that the local cursor motions encoded +in +.I terminfo +are undefined at the left and top edges of a \s-1CRT\s0 terminal. +Programs should never attempt to backspace around the left edge, +unless +.B bw +is given, +and never attempt to go up locally off the top. +In order to scroll text up, a program will go to the bottom left corner +of the screen and send the +.B ind +(index) string. +.PP +To scroll text down, a program goes to the top left corner +of the screen and sends the +.B ri +(reverse index) string. +The strings +.B ind +and +.B ri +are undefined when not on their respective corners of the screen. +.PP +Parameterized versions of the scrolling sequences are +.B indn +and +.B rin +which have the same semantics as +.B ind +and +.B ri +except that they take one parameter, and scroll that many lines. +They are also undefined except at the appropriate edge of the screen. +.PP +The \fBam\fR capability tells whether the cursor sticks at the right +edge of the screen when text is output, but this does not necessarily +apply to a +.B cuf1 +from the last column. +The only local motion which is defined from the left edge is if +.B bw +is given, then a +.B cub1 +from the left edge will move to the right edge of the previous row. +If +.B bw +is not given, the effect is undefined. +This is useful for drawing a box around the edge of the screen, for example. +If the terminal has switch selectable automatic margins, +the +.I terminfo +file usually assumes that this is on; i.e., \fBam\fR. +If the terminal has a command which moves to the first column of the next +line, that command can be given as +.B nel +(newline). +It does not matter if the command clears the remainder of the current line, +so if the terminal has no +.B cr +and +.B lf +it may still be possible to craft a working +.B nel +out of one or both of them. +.PP +These capabilities suffice to describe hardcopy and \*(lqglass-tty\*(rq terminals. +Thus the model 33 teletype is described as +.PP +.DT +.nf +.ft CW +.in -7 + \s-133\||\|tty33\||\|tty\||\|model 33 teletype, + bel=^G, cols#72, cr=^M, cud1=^J, hc, ind=^J, os,\s+1 +.in +7 +.ft R +.PP +while the Lear Siegler \s-1ADM\-3\s0 is described as +.PP +.DT +.nf +.ft CW +.in -7 + \s-1adm3\||\|3\||\|lsi adm3, + am, bel=^G, clear=^Z, cols#80, cr=^M, cub1=^H, cud1=^J, + ind=^J, lines#24,\s+1 +.in +7 +.ft R +.fi +.PP +.B Parameterized Strings +.PP +Cursor addressing and other strings requiring parameters +in the terminal are described by a +parameterized string capability, with +.IR printf (3S) +like escapes \fB%x\fR in it. +For example, to address the cursor, the +.B cup +capability is given, using two parameters: +the row and column to address to. +(Rows and columns are numbered from zero and refer to the +physical screen visible to the user, not to any unseen memory.) +If the terminal has memory relative cursor addressing, +that can be indicated by +.BR mrcup . +.PP +The parameter mechanism uses a stack and special \fB%\fP codes +to manipulate it. Typically a sequence will push one of the +parameters onto the stack and then print it in some format. +Often more complex operations are necessary. +.PP +The \fB%\fR encodings have the following meanings: +.PP +.DT +.nf +.ta .5i 1.5i + \s-1%% outputs `%' + %d print pop() as in printf + %2d print pop() like %2d + %3d print pop() like %3d + %02d + %03d as in printf + %c print pop() gives %c + %s print pop() gives %s + + %p[1-9] push ith parm + %P[a-z] set variable [a-z] to pop() + %g[a-z] get variable [a-z] and push it + %'c' char constant c + %{nn} integer constant nn + + %+ %- %* %/ %m + arithmetic (%m is mod): push(pop() op pop()) + %& %| %^ bit operations: push(pop() op pop()) + %= %> %< logical operations: push(pop() op pop()) + %! %~ unary operations push(op pop()) + %i add 1 to first two parms (for ANSI terminals) + + %? expr %t thenpart %e elsepart %; + if-then-else, %e elsepart is optional. + else-if's are possible ala Algol 68: + %? c\d1\u %t b\d1\u %e c\d2\u %t b\d2\u %e c\d3\u %t b\d3\u %e c\d4\u %t b\d4\u %e %; +\s+1 c\di\u are conditions, b\di\u are bodies. +.fi +.PP +Binary operations are in postfix form with the operands in the usual order. +That is, to get x-5 one would use "%gx%{5}%-". +.PP +Consider the HP2645, which, to get to row 3 and column 12, needs +to be sent \eE&a12c03Y padded for 6 milliseconds. Note that the order +of the rows and columns is inverted here, and that the row and column +are printed as two digits. +Thus its \fBcup\fR capability is \*(lqcup=6\eE&%p2%2dc%p1%2dY\*(rq. +.PP +The Microterm \s-1ACT-IV\s0 needs the current row and column sent +preceded by a \fB^T\fR, with the row and column simply encoded in binary, +\*(lqcup=^T%p1%c%p2%c\*(rq. +Terminals which use \*(lq%c\*(rq need to be able to +backspace the cursor (\fBcub1\fR), +and to move the cursor up one line on the screen (\fBcuu1\fR). +This is necessary because it is not always safe to transmit \fB\en\fR +\fB^D\fR and \fB\er\fR, as the system may change or discard them. +(The library routines dealing with terminfo set tty modes so that +tabs are never expanded, so \et is safe to send. +This turns out to be essential for the Ann Arbor 4080.) +.PP +A final example is the \s-1LSI ADM\s0-3a, which uses row and column +offset by a blank character, thus \*(lqcup=\eE=%p1%' '%+%c%p2%' '%+%c\*(rq. +After sending `\eE=', this pushes the first parameter, pushes the +ASCII value for a space (32), adds them (pushing the sum on the stack +in place of the two previous values) and outputs that value as a character. +Then the same is done for the second parameter. +More complex arithmetic is possible using the stack. +.PP +If the terminal has row or column absolute cursor addressing, +these can be given as single parameter capabilities +.B hpa +(horizontal position absolute) +and +.B vpa +(vertical position absolute). +Sometimes these are shorter than the more general two parameter +sequence (as with the hp2645) and can be used in preference to +.B cup . +If there are parameterized local motions (e.g., move +.I n +spaces to the right) these can be given as +.BR cud , +.BR cub , +.BR cuf , +and +.BR cuu +with a single parameter indicating how many spaces to move. +These are primarily useful if the terminal does not have +.BR cup , +such as the \s-1TEKTRONIX\s+1 4025. +.PP +.B Cursor Motions +.PP +If the terminal has a fast way to home the cursor +(to very upper left corner of screen) then this can be given as +\fBhome\fR; similarly a fast way of getting to the lower left-hand corner +can be given as \fBll\fR; this may involve going up with \fBcuu1\fR +from the home position, +but a program should never do this itself (unless \fBll\fR does) because it +can make no assumption about the effect of moving up from the home position. +Note that the home position is the same as addressing to (0,0): +to the top left corner of the screen, not of memory. +(Thus, the \eEH sequence on HP terminals cannot be used for +.BR home .) +.PP +.B Area Clears +.PP +If the terminal can clear from the current position to the end of the +line, leaving the cursor where it is, this should be given as \fBel\fR. +If the terminal can clear from the current position to the end of the +display, then this should be given as \fBed\fR. +\fBEd\fR is only defined from the first column of a line. +(Thus, it can be simulated by a request to delete a large number of lines, +if a true +.B ed +is not available.) +.PP +.B Insert/delete line +.PP +If the terminal can open a new blank line before the line where the cursor +is, this should be given as \fBil1\fR; this is done only from the first +position of a line. The cursor must then appear on the newly blank line. +If the terminal can delete the line which the cursor is on, then this +should be given as \fBdl1\fR; this is done only from the first position on +the line to be deleted. +Versions of +.B il1 +and +.B dl1 +which take a single parameter and insert or delete that many lines can +be given as +.B il +and +.BR dl . +If the terminal has a settable scrolling region (like the vt100) +the command to set this can be described with the +.B csr +capability, which takes two parameters: +the top and bottom lines of the scrolling region. +The cursor position is, alas, undefined after using this command. +It is possible to get the effect of insert or delete line using +this command \- the +.B sc +and +.B rc +(save and restore cursor) commands are also useful. +Inserting lines at the top or bottom of the screen can also be +done using +.B ri +or +.B ind +on many terminals without a true insert/delete line, +and is often faster even on terminals with those features. +.PP +If the terminal has the ability to define a window as part of +memory, which all commands affect, +it should be given as the parameterized string +.BR wind . +The four parameters are the starting and ending lines in memory +and the starting and ending columns in memory, in that order. +.PP +If the terminal can retain display memory above, then the +\fBda\fR capability should be given; if display memory can be retained +below, then \fBdb\fR should be given. These indicate +that deleting a line or scrolling may bring non-blank lines up from below +or that scrolling back with \fBri\fR may bring down non-blank lines. +.PP +.B Insert/Delete Character +.PP +There are two basic kinds of intelligent terminals with respect to +insert/delete character which can be described using +.I terminfo. +The most common insert/delete character operations affect only the characters +on the current line and shift characters off the end of the line rigidly. +Other terminals, such as the Concept 100 and the Perkin Elmer Owl, make +a distinction between typed and untyped blanks on the screen, shifting +upon an insert or delete only to an untyped blank on the screen which is +either eliminated, or expanded to two untyped blanks. You can determine the +kind of terminal you have by clearing the screen and then typing +text separated by cursor motions. Type \*(lqabc\ \ \ \ def\*(rq using local +cursor motions (not spaces) between the \*(lqabc\*(rq and the \*(lqdef\*(rq. +Then position the cursor before the \*(lqabc\*(rq and put the terminal in insert +mode. If typing characters causes the rest of the line to shift +rigidly and characters to fall off the end, then your terminal does +not distinguish between blanks and untyped positions. If the \*(lqabc\*(rq +shifts over to the \*(lqdef\*(rq which then move together around the end of the +current line and onto the next as you insert, you have the second type of +terminal, and should give the capability \fBin\fR, which stands for +\*(lqinsert null\*(rq. +While these are two logically separate attributes (one line vs. multiline +insert mode, and special treatment of untyped spaces) we have seen no +terminals whose insert mode cannot be described with the single attribute. +.PP +Terminfo can describe both terminals which have an insert mode, and terminals +which send a simple sequence to open a blank position on the current line. +Give as \fBsmir\fR the sequence to get into insert mode. +Give as \fBrmir\fR the sequence to leave insert mode. +Now give as \fBich1\fR any sequence needed to be sent just before sending +the character to be inserted. Most terminals with a true insert mode +will not give \fBich1\fR; terminals which send a sequence to open a screen +position should give it here. +(If your terminal has both, insert mode is usually preferable to \fBich1\fP. +Do not give both unless the terminal actually requires both +to be used in combination.) +If post insert padding is needed, give this as a number of milliseconds +in \fBip\fR (a string option). Any other sequence which may need to be +sent after an insert of a single character may also be given in \fBip\fR. +If your terminal needs both to be placed into an `insert mode' and +a special code to precede each inserted character, then both +.BR smir / rmir +and +.B ich1 +can be given, and both will be used. +The +.B ich +capability, with one parameter, +.IR n , +will repeat the effects of +.B ich1 +.I n +times. +.PP +It is occasionally necessary to move around while in insert mode +to delete characters on the same line (e.g., if there is a tab after +the insertion position). If your terminal allows motion while in +insert mode you can give the capability \fBmir\fR to speed up inserting +in this case. Omitting \fBmir\fR will affect only speed. Some terminals +(notably Datamedia's) must not have \fBmir\fR because of the way their +insert mode works. +.PP +Finally, you can specify +.B dch1 +to delete a single character, +.B dch +with one parameter, +.IR n , +to delete +.I n characters, +and delete mode by giving \fBsmdc\fR and \fBrmdc\fR +to enter and exit delete mode (any mode the terminal needs to be placed +in for +.B dch1 +to work). +.PP +A command to erase +.I n +characters (equivalent to outputting +.I n +blanks without moving the cursor) +can be given as +.B ech +with one parameter. +.PP +.B "Highlighting, Underlining, and Visible Bells" +.PP +If your terminal has one or more kinds of display attributes, +these can be represented in a number of different ways. +You should choose one display form as +\f2standout mode\fR, +representing a good, high contrast, easy-on-the-eyes, +format for highlighting error messages and other attention getters. +(If you have a choice, reverse video plus half-bright is good, +or reverse video alone.) +The sequences to enter and exit standout mode +are given as \fBsmso\fR and \fBrmso\fR, respectively. +If the code to change into or out of standout +mode leaves one or even two blank spaces on the screen, +as the TVI 912 and Teleray 1061 do, +then \fBxmc\fR should be given to tell how many spaces are left. +.PP +Codes to begin underlining and end underlining can be given as \fBsmul\fR +and \fBrmul\fR respectively. +If the terminal has a code to underline the current character and move +the cursor one space to the right, +such as the Microterm Mime, +this can be given as \fBuc\fR. +.PP +Other capabilities to enter various highlighting modes include +.B blink +(blinking) +.B bold +(bold or extra bright) +.B dim +(dim or half-bright) +.B invis +(blanking or invisible text) +.B prot +(protected) +.B rev +(reverse video) +.B sgr0 +(turn off +.I all +attribute modes) +.B smacs +(enter alternate character set mode) +and +.B rmacs +(exit alternate character set mode). +Turning on any of these modes singly may or may not turn off other modes. +.PP +If there is a sequence to set arbitrary combinations of modes, +this should be given as +.B sgr +(set attributes), +taking 9 parameters. +Each parameter is either 0 or 1, as the corresponding attribute is on or off. +The 9 parameters are, in order: +standout, underline, reverse, blink, dim, bold, blank, protect, alternate +character set. +Not all modes need be supported by +.BR sgr , +only those for which corresponding separate attribute commands exist. +.PP +Terminals with the ``magic cookie'' glitch +.RB ( xmc ) +deposit special ``cookies'' when they receive mode-setting sequences, +which affect the display algorithm rather than having extra bits for +each character. +Some terminals, such as the HP 2621, automatically leave standout +mode when they move to a new line or the cursor is addressed. +Programs using standout mode should exit standout mode before +moving the cursor or sending a newline, +unless the +.B msgr +capability, asserting that it is safe to move in standout mode, is present. +.PP +If the terminal has +a way of flashing the screen to indicate an error quietly (a bell replacement) +then this can be given as \fBflash\fR; it must not move the cursor. +.PP +If the cursor needs to be made more visible than normal when it is +not on the bottom line (to make, for example, a non-blinking underline into an +easier to find block or blinking underline) +give this sequence as +.BR cvvis . +If there is a way to make the cursor completely invisible, give that as +.BR civis . +The capability +.BR cnorm +should be given which undoes the effects of both of these modes. +.PP +If the terminal needs to be in a special mode when running +a program that uses these capabilities, +the codes to enter and exit this mode can be given as \fBsmcup\fR and \fBrmcup\fR. +This arises, for example, from terminals like the Concept with more than +one page of memory. +If the terminal has only memory relative cursor addressing and not screen +relative cursor addressing, a one screen-sized window must be fixed into +the terminal for cursor addressing to work properly. +This is also used for the \s-1TEKTRONIX\s+1 4025, +where +.B smcup +sets the command character to be the one used by terminfo. +.PP +If your terminal correctly generates underlined characters +(with no special codes needed) +even though it does not overstrike, +then you should give the capability \fBul\fR. +If overstrikes are erasable with a blank, +then this should be indicated by giving \fBeo\fR. +.PP +.B Keypad +.PP +If the terminal has a keypad that transmits codes when the keys are pressed, +this information can be given. Note that it is not possible to handle +terminals where the keypad only works in local (this applies, for example, +to the unshifted HP 2621 keys). +If the keypad can be set to transmit or not transmit, +give these codes as \fBsmkx\fR and \fBrmkx\fR. +Otherwise the keypad is assumed to always transmit. +The codes sent by the left arrow, right arrow, up arrow, down arrow, +and home keys can be given as \fBkcub1, kcuf1, kcuu1, kcud1, +\fRand\fB khome\fR respectively. +If there are function keys such as f0, f1, ..., f10, the codes they send +can be given as \fBkf0, kf1, ..., kf10\fR. +If these keys have labels other than the default f0 through f10, the labels +can be given as \fBlf0, lf1, ..., lf10\fR. +The codes transmitted by certain other special keys can be given: +.B kll +(home down), +.B kbs +(backspace), +.B ktbc +(clear all tabs), +.B kctab +(clear the tab stop in this column), +.B kclr +(clear screen or erase key), +.B kdch1 +(delete character), +.B kdl1 +(delete line), +.B krmir +(exit insert mode), +.B kel +(clear to end of line), +.B ked +(clear to end of screen), +.B kich1 +(insert character or enter insert mode), +.B kil1 +(insert line), +.B knp +(next page), +.B kpp +(previous page), +.B kind +(scroll forward/down), +.B kri +(scroll backward/up), +.B khts +(set a tab stop in this column). +In addition, if the keypad has a 3 by 3 array of keys including the four +arrow keys, the other five keys can be given as +.BR ka1 , +.BR ka3 , +.BR kb2 , +.BR kc1 , +and +.BR kc3 . +These keys are useful when the effects of a 3 by 3 directional pad are needed. +.PP +.B Tabs and Initialization +.PP +If the terminal has hardware tabs, the command to advance to the next +tab stop can be given as +.B ht +(usually control I). +A ``backtab'' command which moves leftward to the next tab stop can +be given as +.BR cbt . +By convention, if the teletype modes indicate that tabs are being +expanded by the computer rather than being sent to the terminal, +programs should not use +.B ht +or +.B cbt +even if they are present, since the user may not have the tab stops +properly set. +If the terminal has hardware tabs which are initially set every +.I n +spaces when the terminal is powered up, +the numeric parameter +.B it +is given, showing the number of spaces the tabs are set to. +This is normally used by the +.IR tset +command to determine whether to set the mode for hardware tab expansion, +and whether to set the tab stops. +If the terminal has tab stops that can be saved in nonvolatile memory, +the terminfo description can assume that they are properly set. +.PP +Other capabilities +include +.BR is1 , +.BR is2 , +and +.BR is3 , +initialization strings for the terminal, +.BR iprog , +the path name of a program to be run to initialize the terminal, +and \fBif\fR, the name of a file containing long initialization strings. +These strings are expected to set the terminal into modes consistent +with the rest of the terminfo description. +They are normally sent to the terminal, by the +.IR tset +program, each time the user logs in. +They will be printed in the following order: +.BR is1 ; +.BR is2 ; +setting tabs using +.B tbc +and +.BR hts ; +.BR if ; +running the program +.BR iprog ; +and finally +.BR is3 . +Most initialization is done with +.BR is2 . +Special terminal modes can be set up without duplicating strings +by putting the common sequences in +.B is2 +and special cases in +.B is1 +and +.BR is3 . +A pair of sequences that does a harder reset from a totally unknown state +can be analogously given as +.BR rs1 , +.BR rs2 , +.BR rf , +and +.BR rs3 , +analogous to +.B is2 +and +.BR if . +These strings are output by the +.IR reset +program, which is used when the terminal gets into a wedged state. +Commands are normally placed in +.B rs2 +and +.B rf +only if they produce annoying effects on the screen and are not +necessary when logging in. +For example, the command to set the vt100 into 80-column mode would +normally be part of +.BR is2 , +but it causes an annoying glitch of the screen and is not normally +needed since the terminal is usually already in 80 column mode. +.PP +If there are commands to set and clear tab stops, they can be given as +.B tbc +(clear all tab stops) +and +.B hts +(set a tab stop in the current column of every row). +If a more complex sequence is needed to set the tabs than can be +described by this, the sequence can be placed in +.B is2 +or +.BR if . +.PP +Delays +.PP +Certain capabilities control padding in the teletype driver. +These are primarily needed by hard copy terminals, and are used +by the +.IR tset +program to set teletype modes appropriately. +Delays embedded in the capabilities +.BR cr , +.BR ind , +.BR cub1 , +.BR ff , +and +.B tab +will cause the appropriate delay bits to be set in the teletype driver. +If +.B pb +(padding baud rate) +is given, +these values can be ignored at baud rates below the value of +.BR pb . +.PP +.B Miscellaneous +.PP +If the terminal requires other than a null (zero) character as a pad, +then this can be given as \fBpad\fR. +Only the first character of the +.B pad +string is used. +.PP +If the terminal has an extra ``status line'' that is not normally +used by software, this fact can be indicated. +If the status line is viewed as an extra line below the bottom line, +into which one can cursor address normally +(such as the Heathkit h19's 25th line, or the 24th line of a vt100 +which is set to a 23-line scrolling region), +the capability +.B hs +should be given. +Special strings to go to the beginning of the status +line and to return from the status line can be given as +.B tsl +and +.BR fsl . +.RB ( fsl +must leave the cursor position in the same place it was before +.BR tsl . +If necessary, the +.B sc +and +.B rc +strings can be included in +.B tsl +and +.B fsl +to get this effect.) +The parameter +.B tsl +takes one parameter, which is the column number of the status line +the cursor is to be moved to. +If escape sequences and other special commands, such as tab, work +while in the status line, the flag +.B eslok +can be given. +A string which turns off the status line (or otherwise erases its +contents) should be given as +.BR dsl . +If the terminal has commands to save and restore the position of the cursor, +give them as +.B sc +and +.BR rc . +The status line is normally assumed to be the same width as the rest +of the screen, e.g., +.BR cols . +If the status line is a different width (possibly because the terminal +does not allow an entire line to be loaded) the width, in columns, +can be indicated with the numeric parameter +.BR wsl . +.PP +If the terminal can move up or down half a line, +this can be indicated with +.B hu +(half-line up) +and +.B hd +(half-line down). +This is primarily useful for superscripts and subscripts on hardcopy terminals. +If a hardcopy terminal can eject to the next page (form feed), give this as +.B ff +(usually control L). +.PP +If there is a command to repeat a given character a given number of +times (to save time transmitting a large number of identical characters) +this can be indicated with the parameterized string +.BR rep . +The first parameter is the character to be repeated and the second +is the number of times to repeat it. +Thus, tparm(repeat_char, 'x', 10) is the same as `xxxxxxxxxx'. +.PP +If the terminal has a settable command character, such as the \s-1TEKTRONIX\s+1 4025, +this can be indicated with +.BR cmdch . +A prototype command character is chosen which is used in all capabilities. +This character is given in the +.B cmdch +capability to identify it. +The following convention is supported on some UNIX systems: +The environment is to be searched for a +.B CC +variable, and if found, all +occurrences of the prototype character are replaced with the character +in the environment variable. +.PP +Terminal descriptions that do not represent a specific kind of known +terminal, such as +.IR switch , +.IR dialup , +.IR patch , +and +.IR network , +should include the +.B gn +(generic) capability so that programs can complain that they do not know +how to talk to the terminal. +(This capability does not apply to +.I virtual +terminal descriptions for which the escape sequences are known.) +.PP +If the terminal uses xon/xoff handshaking for flow control, give +.BR xon . +Padding information should still be included so that routines can +make better decisions about costs, but actual pad characters will +not be transmitted. +.PP +If the terminal has a ``meta key'' which acts as a shift key, +setting the 8th bit of any character transmitted, this fact can +be indicated with +.BR km . +Otherwise, software will assume that the 8th bit is parity and it +will usually be cleared. +If strings exist to turn this ``meta mode'' on and off, they +can be given as +.B smm +and +.BR rmm . +.PP +If the terminal has more lines of memory than will fit on the screen +at once, the number of lines of memory can be indicated with +.BR lm . +A value of +.BR lm #0 +indicates that the number of lines is not fixed, +but that there is still more memory than fits on the screen. +.PP +If the terminal is one of those supported by the \s-1UNIX\s+1 virtual +terminal protocol, the terminal number can be given as +.BR vt . +.PP +Media copy +strings which control an auxiliary printer connected to the terminal +can be given as +.BR mc0 : +print the contents of the screen, +.BR mc4 : +turn off the printer, and +.BR mc5 : +turn on the printer. +When the printer is on, all text sent to the terminal will be sent +to the printer. +It is undefined whether the text is also displayed on the terminal screen +when the printer is on. +A variation +.B mc5p +takes one parameter, and leaves the printer on for as many characters +as the value of the parameter, then turns the printer off. +The parameter should not exceed 255. +All text, including +.BR mc4 , +is transparently passed to the printer while an +.B mc5p +is in effect. +.PP +Strings to program function keys can be given as +.BR pfkey , +.BR pfloc , +and +.BR pfx . +Each of these strings takes two parameters: the function key number to +program (from 0 to 10) and the string to program it with. +Function key numbers out of this range may program undefined keys in +a terminal dependent manner. +The difference between the capabilities is that +.B pfkey +causes pressing the given key to be the same as the user typing the +given string; +.B pfloc +causes the string to be executed by the terminal in local; and +.B pfx +causes the string to be transmitted to the computer. +.PP +.B Glitches and Braindamage +.PP +Hazeltine terminals, which do not allow `~' characters to be displayed should +indicate \fBhz\fR. +.PP +Terminals which ignore a linefeed immediately after an \fBam\fR wrap, +such as the Concept and vt100, +should indicate \fBxenl\fR. +.PP +If +.B el +is required to get rid of standout +(instead of merely writing normal text on top of it), +\fBxhp\fP should be given. +.PP +Teleray terminals, where tabs turn all characters moved over to blanks, +should indicate \fBxt\fR (destructive tabs). +Note: the variable indicating this is now `dest_tabs_magic_smso'; in +older versions, it was teleray_glitch. +This glitch is also taken to mean that it is not possible to position +the cursor on top of a ``magic cookie'', +that to erase standout mode it is instead necessary to use +delete and insert line. +.PP +The Beehive Superbee, which is unable to correctly transmit the escape +or control C characters, has +.BR xsb , +indicating that the f1 key is used for escape and f2 for control C. +(Only certain Superbees have this problem, depending on the ROM.) +Note that in older terminfo versions, this capability was called +`beehive_glitch'; it is now `no_esc_ctl_c'. +.PP +Other specific terminal problems may be corrected by adding more +capabilities of the form \fBx\fIx\fR. +.PP +.B Similar Terminals +.PP +If there are two very similar terminals, +one can be defined as being just like the other with certain exceptions. +The string capability \fBuse\fR can be given +with the name of the similar terminal. +The capabilities given before +.B use +override those in the terminal type invoked by +.BR use . +A capability can be cancelled by placing \fBxx@\fR to the left of the +capability definition, where xx is the capability. +For example, the entry +.PP + 2621-nl, smkx@, rmkx@, use=2621, +.PP +defines a 2621-nl that does not have the \fBsmkx\fR or \fBrmkx\fR capabilities, +and hence does not turn on the function key labels when in visual mode. +This is useful for different modes for a terminal, or for different +user preferences. +.SH FILES +.TP 25 +\*d/?/* +files containing terminal descriptions +.SH "SEE ALSO" +tic(1m), curses(3X), printf(3S), term(\*n). +.SH AUTHORS +Pavel Curtis, Zeyd M. Ben-Halim +.\"# +.\"# The following sets edit modes for GNU EMACS +.\"# Local Variables: +.\"# mode:nroff +.\"# fill-column:79 +.\"# End: diff --git a/lib/libncurses/unctrl.h b/lib/libncurses/unctrl.h new file mode 100644 index 000000000000..c80689c06005 --- /dev/null +++ b/lib/libncurses/unctrl.h @@ -0,0 +1,21 @@ + +/* + * unctrl.h + * + * Display a printable version of a control character. + * Control characters are displayed in caret notation (^x), DELETE is displayed + * as ^?. Printable characters sre displatyed as is. + * + * The returned pointer points to a static buffer which gets overwritten by + * each call. Therefore, you must copy the resulting string to a safe place + * before calling unctrl() again. + * + */ +#ifndef _UNCTRL_H +#define _UNCTRL_H 1 + +#include + +extern char *unctrl __P((unsigned char)); + +#endif /* _UNCTRL_H */ diff --git a/lib/libncurses/version.h b/lib/libncurses/version.h new file mode 100644 index 000000000000..15ec8927b94f --- /dev/null +++ b/lib/libncurses/version.h @@ -0,0 +1,3 @@ + +#define NCURSES_VERSION "1.8.5" +