home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Power-Programmierung
/
CD1.mdf
/
magazine
/
drdobbs
/
1987
/
07
/
holub.lst
< prev
next >
Wrap
File List
|
1987-07-28
|
44KB
|
1,158 lines
Listing 1 -- vbios.c
1| #include <stdio.h>
2| #include <dos.h> /* (Microsoft file) includes for int86() */
3|
4| /* VBIOS.C: Various cursor and i/o routine using
5| * the bios interrupts (see below for greater detail):
6| *----------------------------------------------------------
7| * Copyright (C) 1987 Allen I. Holub. All rights reserved.
8| *----------------------------------------------------------
9| * Externally accessable routines:
10| *
11| * int vb_getpage () Get active video page #
12| * void vb_putchar (c) write a single character
13| * void vb_getchar (c) get a key from the bios.
14| * void vb_puts (s, move) write a string
15| * void vb_replace (c) write char w/o moving cursor
16| * int vb_inchar (attrib) Get character & attribute
17| *
18| * void vb_setcur (posn) Set cur pos as int on cur page
19| * int vb_getcur () Get cur pos as int from cur page
20| * void vb_ctoyx (y,x) Set cursor position to (y,x)
21| * void vb_getyx (&y, &x) Get cursor position
22| *
23| * int vb_iscolor() color monitor installed
24| * void vb_cursize (top,bot) Set cursor size
25| * void vb_blockcur() make a block cursor
26| * void vb_normalcur() revert to a normal cursor
27| *
28| * void vb_scroll(l,r,t,b,a) Scroll region
29| */
30|
31| /*--------------------------------------------------------*/
32|
33| extern int int86( int, union REGS *, union REGS *);
34|
35| /*--------------------------------------------------------*/
36|
37| #define VIDEO_INT 0x10 /* Video interrupt */
38| #define KB_INT 0x16 /* Keyboard interrupt */
39|
40| #define CUR_SIZE 0x1 /* Set cursor size */
41| #define SET_POSN 0x2 /* Modify cursor posn */
42| #define READ_POSN 0x3 /* Read current cursor posn */
43| #define WRITE 0x9 /* Write character */
44| #define WRITE_TTY 0xe /* Write char & move cursor */
45| #define GET_VMODE 0xf /* Get video mode & disp pg */
46|
47| /*--------------------------------------------------------*/
48|
49| static union REGS Regs; /* Used to talk to DOS */
50| static int Attribute; /* Current attribute */
51|
52| /*--------------------------------------------------------*/
53|
54| void vb_scroll( x_left, x_right, y_top, y_bottom, amt )
55| {
56| /* Scroll the indicated region on the screen.
57| * If amt is negative, scroll down.
58| */
59|
60| if( amt < 0 )
61| {
62| Regs.h.ah = 7 ;
63| Regs.h.al = -amt ;
64| }
65| else
66| {
67| Regs.h.ah = 6 ;
68| Regs.h.al = amt ;
69| }
70|
71| Regs.h.bh = 0x07 ;
72| Regs.h.cl = x_left ;
73| Regs.h.ch = y_top ;
74| Regs.h.dl = x_right ;
75| Regs.h.dh = y_bottom ;
76| int86(0x10, &Regs, &Regs);
77| }
78|
79| /*--------------------------------------------------------*/
80|
81| int vb_inchar( attrib )
82| int *attrib;
83| {
84| /* Return the character at the current cursor
85| * position and, if attrib is non-NULL, put the
86| * attribute there. Note that vb_getpage() will mess
87| * up the fields in the Regs structure so it must
88| * be called first.
89| */
90|
91| Regs.h.bh = vb_getpage() ;
92| Regs.h.ah = 8 ;
93|
94| int86( VIDEO_INT, &Regs, &Regs );
95|
96| if( attrib )
97| *attrib = Regs.h.ah & 0xff ;
98|
99| return( Regs.h.al & 0xff );
100| }
101|
102| /*--------------------------------------------------------*/
103|
104| int vb_getpage()
105| {
106| /* Returns the currently active display page number
107| */
108|
109| Regs.h.ah = GET_VMODE;
110| int86( VIDEO_INT, &Regs, &Regs );
111|
112| return (int) Regs.h.bh ;
113| }
114|
115| /*--------------------------------------------------------*/
116|
117| void vb_cursize( top_line, bot_line )
118| {
119| /* Scan lines are numberd 0 at the top and 7 at the
120| * bottom on the color card. On the monochrome card
121| * they're 0-12. If top & bot are reversed you'll
122| * get a 2 part cursor. Top_line determines the
123| * position of the top scan line of the cursor,
124| * bot_line is the bottom. A normal cursor can be
125| * created with vb_cursize(6,7). Cursize(0,7) will
126| * fill the entire area occupied by a character.
127| * Cursize(0,1) will put a line over the character
128| * rather than under it.
129| */
130|
131| Regs.h.ch = top_line ;
132| Regs.h.cl = bot_line ;
133| Regs.h.ah = CUR_SIZE ;
134| int86( VIDEO_INT, &Regs, &Regs );
135| }
136|
137| /*--------------------------------------------------------*/
138|
139| int vb_iscolor() /* Returns true if a color card is active */
140| {
141| Regs.h.ah = GET_VMODE ;
142| int86( VIDEO_INT, &Regs, &Regs );
143| return( Regs.h.al != 7 );
144| }
145|
146| void vb_blockcur() /* Make the cursor a block curser */
147| {
148| vb_cursize( 0, vb_iscolor() ? 7 : 12 );
149| }
150|
151| void vb_normalcur() /* Make it an underline cursor */
152| {
153| if( vb_iscolor() )
154| vb_cursize( 6, 7 );
155| else
156| vb_cursize( 11, 12 );
157| }
158|
159| /*--------------------------------------------------------*/
160|
161| void vb_setcur( posn )
162| int posn;
163| {
164| /* Modify current cursor position. The top byte of
165| * "posn" value holds the row (y), the bottom byte,
166| * the column (x). The top-left corner of the screen
167| * is (0,0). Pagenum is the video page number. Note
168| * that vb_getpage() will mess up the fields in the
169| * Regs structure so it must be called first.
170| */
171|
172| Regs.h.bh = vb_getpage() ;
173| Regs.x.dx = posn ;
174| Regs.h.ah = SET_POSN ;
175| int86( VIDEO_INT, &Regs, &Regs );
176| }
177|
178| int vb_getcur()
179| {
180| /* Get current cursor position. The top byte of the
181| * return value holds the row, the bottom by the
182| * column. Pagenum is the video page number. Note
183| * that vb_getpage() will mess up the fields in the
184| * Regs structure so it must be called first.
185| */
186|
187| Regs.h.bh = vb_getpage() ;
188| Regs.h.ah = READ_POSN ;
189| int86( VIDEO_INT, &Regs, &Regs );
190| return( Regs.x.dx );
191| }
192|
193| /*----------------------------------------------------------
194| * vb_cotyx() and vb_getyx also get the cursor position.
195| * They use x and y values, however.
196| */
197|
198| void vb_ctoyx ( y, x )
199| {
200| vb_setcur( (y << 8) | (x & 0xff) );
201| }
202|
203| void vb_getyx( yp, xp )
204| int *yp, *xp;
205| {
206| register int posn;
207|
208| posn = vb_getcur();
209| *xp = posn & 0xff ;
210| *yp = (posn >> 8) & 0xff ;
211| }
212|
213| /*--------------------------------------------------------*/
214|
215| vb_replace(c)
216| {
217| /* Overwrite the character at the current cursor
218| * position without moving the cursor.
219| */
220|
221| Regs.h.ah = 10 ;
222| Regs.h.al = c; /* write c */
223| Regs.h.bl = 0x07; /* Normal characters */
224| Regs.h.bh = 0; /* Display page 0 */
225| Regs.x.cx = 1; /* # of times to write */
226|
227| int86( VIDEO_INT, &Regs, &Regs );
228| }
229|
230| /*--------------------------------------------------------*/
231|
232| vb_putchar( c )
233| {
234| /* Write a character to the screen in TTY mode.
235| * Only normal printing characters, BS, BEL, CR and
236| * LF are recognized. The cursor is automatically
237| * advanced and lines will wrap.
238| */
239|
240| Regs.h.bl = 0x07;
241| Regs.h.al = c;
242| Regs.h.ah = WRITE_TTY ;
243| int86( VIDEO_INT, &Regs, &Regs );
244| }
245|
246| /*--------------------------------------------------------*/
247|
248| vb_puts( str, move_cur )
249| register char *str;
250| {
251| /* Write a string to the screen in TTY mode. If
252| * move_cur is true the cursor is left at the end
253| * of string. If not the cursor will be restored to
254| * its original position (before the write).
255| */
256|
257| register int posn;
258|
259| if( !move_cur )
260| posn = vb_getcur();
261|
262| while( *str )
263| vb_putchar( *str++ );
264|
265| if( !move_cur )
266| vb_setcur( posn );
267| }
268|
269| /*--------------------------------------------------------*/
270|
271| int vb_getchar()
272| {
273| /* Get a character with a direct video bios call.
274| * This routine can be used to complement stderr as
275| * it can be used to get characters from the keyboard,
276| * even when input redirected. The typed character
277| * is returned in the low byte of the returned
278| * integer, the high byte holds the auxillary byte
279| * used to mark ALT keys and such. See the Technical
280| * Reference for more info.
281| */
282|
283| Regs.h.ah = 0 ;
284| int86( KB_INT, &Regs, &Regs );
285| return( (int)Regs.x.ax );
286| }
287|
288| /*--------------------------------------------------------*/
289| #ifdef MAIN
290|
291| main()
292| {
293| vb_replace( 'X' );
294| vb_putchar('\n');
295| vb_putchar('\r');
296| }
297|
298| #endif
Listing 2 -- /include/box.h
1| /*-------------------------------------------------------*
2| * BOX.H: Copyright (c) 1987, Allen I. Holub.
3| * All rights reserved.
4| *
5| * #defines for the box-drawing characters on the IBM PC.
6| *
7| *-------------------------------------------------------*
8| * The names are:
9| *
10| * UL Upper left corner
11| * UR Upper right corner
12| * LL lower left corner
13| * LR lower right corner
14| * CEN Center (intersection of two lines)
15| * TOP Tee with the flat piece on top
16| * BOT Bottom tee
17| * LEFT Left tee
18| * RIGHT Right tee
19| * HORIZ Horizontal line
20| * VERT Vertical line.
21| *
22| *
23| * UL -TOP- UR HORIZ
24| * |
25| * L R V
26| * E | I E
27| * F-- -CEN- --G R
28| * T | H T
29| * | T
30| * |
31| * LL -BOT- LR
32| *
33| *
34| * The D_XXX defines have double horizontal and vertical lines
35| * The HD_XXX defines have double horizontal lines only
36| * The VD_XXX defines have double vertial lines only
37| *
38| * If your terminal is not IBM compatible, #define all of these
39| * as '+', except for the VERT #defines, which should be a |,
40| * and the HORIZ #defines, which should be a -.
41| */
42|
43| #define VERT 179
44| #define RIGHT 180
45| #define UR 191
46| #define LL 192
47| #define BOT 193
48| #define TOP 194
49| #define LEFT 195
50| #define HORIZ 196
51| #define CEN 197
52| #define LR 217
53| #define UL 218
54|
55| #define D_VERT 186
56| #define D_RIGHT 185
57| #define D_UR 187
58| #define D_LL 200
59| #define D_BOT 202
60| #define D_TOP 203
61| #define D_LEFT 204
62| #define D_HORIZ 205
63| #define D_CEN 206
64| #define D_LR 188
65| #define D_UL 201
66|
67| #define HD_VERT 179
68| #define HD_RIGHT 181
69| #define HD_UR 184
70| #define HD_LL 212
71| #define HD_BOT 207
72| #define HD_TOP 209
73| #define HD_LEFT 198
74| #define HD_HORIZ 205
75| #define HD_CEN 216
76| #define HD_LR 190
77| #define HD_UL 213
78|
79| #define VD_VERT 186
80| #define VD_RIGHT 182
81| #define VD_UR 183
82| #define VD_LL 211
83| #define VD_BOT 208
84| #define VD_TOP 210
85| #define VD_LEFT 199
86| #define VD_HORIZ 196
87| #define VD_CEN 215
88| #define VD_LR 189
89| #define VD_UL 214
Listing 3 -- /include/curses.h
1| /*-------------------------------------------------------*
2| * CURSES.H: Copyright (c) 1987, Allen I. Holub. *
3| * All rights reserved. *
4| *-------------------------------------------------------*
5| */
6|
7| typedef struct
8| {
9| int x_org; /* X coordinate of upper-left corner */
10| int y_org; /* Y coordinate of upper-left corner */
11| int x_size; /* Horizontal size of text area. */
12| int y_size; /* Vertical size of text area. */
13| int row; /* Current cursor row (0 to y_size-1) */
14| int col; /* Current cursor column (0 to x_size-1)*/
15| int scroll_ok; /* Scrolling permitted in this window */
16| }
17| WINDOW;
18|
19| # define bool unsigned int
20| # define reg register
21| # define TRUE (1)
22| # define FALSE (0)
23| # define ERR (0)
24| # define OK (1)
25|
26| /*------------------------------------------------------------
27| * Reminder: The comma opperator goes left to right and
28| * evaluates to the rightmost thing in the list.
29| *
30| * The following macros implement many of the curses functions
31| * note that stdscr only has meaning when passed to getyx.
32| *------------------------------------------------------------
33| */
34|
35| #define stdscr 0
36|
37| #define getyx(win,y,x) (win ? ((x)=win->col,(y)=win->row) \
38| : getpos(&x,&y))
39|
40| #define mvinch(y,x) ( move ( y,x), inch ( ) )
41| #define mvwinch(w,y,x) ( wmove(w,y,x), winch(w) )
42|
43| #define addch(c) putchar(c)
44| #define endwin()
45| #define erase() clear()
46| #define initscr()
47| #define printw printf
48| #define refresh()
49| #define scroll(w) wscroll(w,1);
50| #define scrollok(win,flag) ((win)->scroll_ok = (flag))
51| #define subwin(w,a,b,c,d) newwin(a,b,c,d)
52| #define wclear werase
53| #define wrefresh(win)
54|
55| /*----------------------------------------------------------*/
56|
57| extern WINDOW *newwin (int ,int ,int ,int );
58| extern int box (WINDOW *,int ,int );
59| extern int clear (void);
60| extern int crmode (void);
61| extern int echo (void);
62| extern int getch (void);
63| extern int move (int ,int );
64| extern int nl (void);
65| extern int nocrmode (void);
66| extern int noecho (void);
67| extern int nonl (void);
68| extern int waddch (WINDOW *, int );
69| extern int waddstr (WINDOW *, char *);
70| extern int wclrtoeol (WINDOW * );
71| extern int werase (WINDOW * );
72| extern int wgetch (WINDOW * );
73| extern int wmove (WINDOW *, int ,int );
74| extern int wprintw (WINDOW *, char *,... );
75| extern int wscroll (WINDOW *, int );
Listing 4 -- curses.c
1| #include <stdio.h>
2| #include <ctype.h>
3| #include <curses.h> /* routines in this file. */
4| #include <box.h> /* of IBM box-drawing characters */
5| #include <stdarg.h> /* va_list and va_start (ANSI) */
6|
7| /*-------------------------------------------------------*
8| * CURSES.C: Copyright (c) 1987, Allen I. Holub. *
9| * All rights reserved. *
10| *-------------------------------------------------------*
11| *
12| * This file is a DOS implementation of some of the Unix
13| * CURSES functions. It is Unix compatible but is a proper
14| * subset, not a full implementation, of curses. It works
15| * on the IBM-PC. In all of these y is the row number and
16| * x is the column number. The upper left corner is (0,0):
17| *
18| * I/O functions ------------------------------------------
19| *
20| * waddch( win, ch ) Works like putc()
21| * waddstr( win, str) Works like puts()
22| * wprintw(win,fmt,arg...) Like printf but writes to the
23| * indicated window.
24| * wrefresh(win) See below.
25| * box(win, vert, horiz) Draws a box around the window.
26| *
27| * Cursor movement and screen control ---------------------
28| *
29| * werase(win) erase the entire window
30| * wclrtoeol(win) erase from cursor position to the end
31| * of line
32| *
33| * wmove(win,y,x) Move the cursor to postion (y,x) rela-
34| * tive to the orgin of the indicated window.
35| *
36| * getxy(win,y,x) MACRO: puts the current cursor postion
37| * into y and x. Note that this is a macro,
38| * don't put an & in front of y and x in
39| * the invocation.
40| *
41| * wgetch(win) works like getchar but echos to the
42| * indicated window. If crmode is
43| * inactive, it is activated for the
44| * duration of this subroutine.
45| *
46| * scroll(win) Scrolls the window up one line.
47| * wscroll( win, amt ) NOT A CURSES FUNCTION. Scrolls
48| * window by indicated amount. A
49| * negaitve amt scrolls down.
50| *
51| * Initialization stuff -------------------------------------
52| *
53| * initscr() Initialize
54| * endwin() Clean up
55| * scrollok(win, flag); enable/disable scrolling for window.
56| * newwin(lines,cols,begin_y,begin_x) Create a new window.
57| *
58| * Terminal control -----------------------------------------
59| * Because of the perversities of DOS, these work in a
60| * slightly nonstandard way. In particular echo, noecho,
61| * nl, and nonl only work if crmode() is active.
62| * Moreover, they are ignored for the non-w fundtions.
63| * For portability reasons, it's best to always set
64| * crmode() at the top of your program.
65| *
66| * crmode(); Turn off input buffering.
67| * nocrmode(); Turn it back on again. (default)
68| * noecho(); Turn off automatic echo.
69| * echo(); Turn it back on again. (default)
70| * nl(); Turn on CR-NL mapping (default)
71| * nonl(); turn it off again.
72| *
73| * Functions that affect the whole screen. ------------------
74| *
75| * move(y,x) move cursor to abs. position (y,x)
76| * addch(c) Write a character.
77| * clear() Clear the screen
78| * printw() works like printf
79| * getch() get a character from the keyboard.
80| * refresh() See below.
81| *
82| *-----------------------------------------------------------
83| * The real curses keeps an two internal representations of
84| * the screen, when you change something it just modifies
85| * one of these reprsentations. You must issue a refresh()
86| * or wrefresh() call to actually modify the screen. My
87| * version of curses refreshes the screen immediately after
88| * every write. refresh() and wrefresh() macros have been
89| * provided for UNIX compatability, however. These macros
90| * don't do anything, but you should scatter them liberally
91| * about your code if you want it to be portable.
92| *
93| * I've corrected one bug in the real curses that might
94| * cause problems when you port your code. The real curses
95| * (at least the one at Berkeley), doesn't scroll properly
96| * in that it leaves junk on the bottom line of the window
97| * after a scroll. I've corrected the problem here but,
98| * again, if you want real portability you should do a
99| * wclrtoeol(win) after every scroll. Unfortunately, there's
100| * no way to determine that the screen has scrolled without
101| * actually keeping track of the characters that are written
102| * to the screen. Ugh.
103| *
104| * Other differences: curses doesn't know about characters
105| * that it hasn't actually put on the screen with an addch().
106| * So, if echo is enabled, curses won't erase the echoed
107| * characters when it scrolls the screen and so forth. The
108| * curses presented here doesn't exibit this behaviour, but
109| * if you want compatablility with Unix, turn off echo (with
110| * a noecho() call) and then echo all characters yourself.
111| *
112| * The purpose of the four #defines immediately below is to
113| * make it easy to modify this package. They all map function
114| * calls to video-bios subroutines [vb_xxx()]. If you want to
115| * use your own functions (that do direct video access or send
116| * out escape sequences to a normal terminal, for example)
117| * just change the #defines and recompile. The functions must
118| * behave as follows:
119| *
120| * cmove(y,x) Move the cursor to position (y,x) (y is row)
121| * where (0,0) is the upper-left corner of the
122| * screen.
123| * curpos(y,x) Put the (y,x) cursor position into the
124| * integers pointed to by y and x.
125| * replace(c) Print c at the current cursor position without
126| * moving the cursor. This routine must be able
127| * to put a character into the 80th column
128| * without scrolling the screen or wrapping
129| * around.
130| *
131| * doscroll(l,r,t,b,a) Scroll a region of the screen with the
132| * top left corner at (t,l) and the bottom
133| * right corner at (b,r). "a" is the number of
134| * lines to scroll (up if a is positive, down if
135| * it's negative).
136| *
137| * inchar() Returns the character at the current curser
138| * position.
139| */
140|
141| #define cmove(y,x) vb_ctoyx(y,x);
142| #define curpos(y,x) vb_getyx(y,x);
143| #define replace(c) vb_replace(c);
144| #define doscroll(l,r,t,b,a) vb_scroll(l,r,t,b,a);
145| #define inchar() vb_inchar(NULL)
146|
147| #define min(a,b) ((a) < (b) ? (a) : (b))
148|
149| /*--------------------------------------------------------*/
150|
151| static int Echo = 1; /* Echo enabled */
152| static int Crmode = 0; /* If 1, use buffered input */
153| static int Nl = 1; /* If 1, map \r to \n on input */
154| /* and map both to \n\r on output */
155|
156| /*--------------------------------------------------------*/
157|
158| noecho ( ) { Echo = 0; }
159| echo ( ) { Echo = 1; }
160| nl ( ) { Nl = 1; }
161| nonl ( ) { Nl = 0; }
162| getpos (yp,xp) { return curpos(yp, xp); }
163| move (y, x ) { cmove(y, x); }
164| inch ( ) { return inchar(); }
165|
166| /*--------------------------------------------------------*/
167|
168| crmode()
169| {
170| FILE *console;
171|
172| setvbuf(stdin, NULL, _IONBF, 0); /* Turn off buffering */
173| Crmode = 1;
174| }
175|
176| nocrmode()
177| {
178| freopen( "/dev/con", "r", stdin );
179| Crmode = 0;
180| }
181|
182| /*--------------------------------------------------------*/
183|
184| WINDOW *newwin( lines, cols, begin_y, begin_x )
185|
186| int cols; /* Horizontal size (including border) */
187| int lines; /* Vergtical size (including bofder) */
188| int begin_y; /* X coordinate of upper-left corner */
189| int begin_x; /* Y coordinate of upper-left corner */
190| {
191| WINDOW *win, *malloc();
192|
193| if( !(win = malloc( sizeof(WINDOW) )) )
194| ferr("Out of memory\n");
195|
196| win->x_org = begin_x;
197| win->y_org = begin_y;
198| win->x_size = cols ;
199| win->y_size = lines ;
200| win->row = 0;
201| win->col = 0;
202| win->scroll_ok = 0;
203|
204| werase(win);
205| return win;
206| }
207|
208| /*--------------------------------------------------------*/
209|
210| int waddch( win, c )
211| WINDOW *win;
212| int c;
213| {
214| /* Print a character: The following are handled
215| * specially:
216| *
217| * \n Clear the line from the current cursor position
218| * to the right edge of the window. Then:
219| * if nl() is active:
220| * go to the left edge of the next line
221| * else
222| * go to the current column on the next line
223| * In addition, if scrolling is enabled, the window
224| * scrolls if you're on the bottom line.
225| * \t is expanded into an 8-space field. If the tab
226| * goes past the right edge of the window, the
227| * cursor wraps to the next line.
228| * \r gets you to the beginning of the current line.
229| *
230| * \b backs up one space but may not back up past
231| * the left edge of the window. Nondestructive. The
232| * curses documentation doesn't say that \b is
233| * handled explicitly but it does indeed work.
234| *
235| * The following is not supported by Unix. Don't use
236| * explicit escape sequences if portability is a
237| * consideration:
238| *
239| * ESC This is not standard curses but is useful. All
240| * characters between an ASCII ESC and an alphabetic
241| * character are sent to the output but are otherwise
242| * igonred. This let's you send escape sequences
243| * directly to the terminal if you like. I'm
244| * assuming here that you won't change windows in the
245| * middle of an escape sequence.
246| *
247| * Return ERR if the character would have caused the
248| * window to scroll illegally.
249| */
250|
251| static int saw_esc = 0;
252| static WINDOW *oldwin = NULL;
253| int rval = OK;
254|
255| if( oldwin != win )
256| {
257| cmove(win->y_org + win->row, win->x_org + win->col);
258| oldwin = win;
259| }
260|
261| if( saw_esc )
262| {
263| if( isalpha( c ) )
264| saw_esc = 0;
265|
266| putchar(c);
267| }
268| else
269| {
270| switch( c )
271| {
272| case '\033':
273| saw_esc = 1;
274| putchar('\033');
275| break;
276|
277| case '\b':
278| if( win->col > 0 )
279| {
280| putchar('\b');
281| --( win->col );
282| }
283| break;
284|
285| case '\t':
286| do
287| {
288| waddch( win, ' ' );
289| }
290| while( win->col % 8 );
291| break;
292|
293| case '\r':
294| win->col = 0;
295| cmove(win->y_org + win->row, win->x_org);
296| break;
297|
298| default :
299| putchar(c);
300| if( ++(win->col) < win->x_size )
301| break;
302|
303| /* fall through to newline */
304|
305| case '\n':
306| wclrtoeol( win );
307|
308| if( Nl )
309| win->col = 0;
310|
311| if( ++(win->row) >= win->y_size )
312| {
313| rval = wscroll( win, 1 );
314| --( win->row );
315| }
316|
317| cmove( win->y_org + win->row,
318| win->x_org + win->col);
319| break;
320| }
321| }
322|
323| return rval;
324| }
325|
326| /*--------------------------------------------------------*/
327|
328| waddstr( win, str )
329| WINDOW *win;
330| char *str;
331| {
332| while( *str )
333| waddch( win, *str );
334| }
335|
336| /*--------------------------------------------------------*/
337|
338| static int Errcode = OK;
339|
340| static wputc(c, win) WINDOW *win;
341| {
342| Errcode |= waddch(win,c);
343| }
344|
345| wprintw(win, fmt)
346| WINDOW *win;
347| char *fmt;
348| {
349| /* The doprnt() function used here is explained in depth
350| * in Allen Holub, The C Companion (Prentice-Hall: 1987),
351| * pp. 213-237. If you don't have this book, an alternate
352| * approach is explained in the text.
353| */
354|
355| va_list args;
356| va_start( args, fmt );
357|
358| Errcode = OK;
359| doprnt( wputc, win, fmt, args );
360| return Errcode;
361| }
362|
363| /*--------------------------------------------------------*/
364|
365| box( win, vert, horiz )
366| WINDOW *win;
367| {
368| /* Draws a box in the outermost characters of the window
369| * using vert for the vertical characters and horiz for
370| * the horizontal ones. I've extended this function to
371| * support the IBM box-drawing characters. That is,
372| * if IBM box-drawing characters are specified for vert
373| * and horiz, box() will use the correct box-drawing
374| * characters in the corners. These are defined in
375| * box.h as:
376| *
377| * HORIZ (0xc4) single horizontal line
378| * D_HORIZ (0xcd) double horizontal line.
379| * VERT (0xb3) single vertical line
380| * D_VERT (0xba) double vertical line.
381| */
382|
383| int i, nrows;
384| int ul, ur, ll, lr;
385|
386| if( !( (horiz == HORIZ || horiz == D_HORIZ) &&
387| (vert == VERT || vert == D_VERT ) ))
388| {
389| ul = ur = ll = lr = vert ;
390| }
391| else
392| {
393| if( vert == VERT )
394| {
395| if(horiz==HORIZ)
396| ul=UL, ur=UR, ll=LL, lr=LR;
397| else
398| ul=HD_UL, ur=HD_UR, ll=HD_LL, lr=HD_LR;
399| }
400| else
401| {
402| if(horiz==HORIZ)
403| ul=VD_UL, ur=VD_UR, ll=VD_LL, lr=VD_LR;
404| else
405| ul=D_UL, ur=D_UR, ll=D_LL, lr=D_LR;
406| }
407| }
408|
409| cmove( win->y_org, win->x_org );
410|
411| putchar( ul ); /* Top line */
412|
413| for( i = win->x_size-2; --i >= 0 ; )
414| putchar( horiz );
415|
416| putchar( ur );
417| nrows = win->y_size - 2 ; /* Two sides */
418| i = win->y_org + 1 ;
419|
420| while( --nrows >= 0 )
421| {
422| cmove( i, win->x_org );
423| putchar( vert );
424|
425| cmove( i++, win->x_org + (win->x_size - 1) );
426| putchar( vert );
427| }
428|
429| cmove(i, win->x_org); /* Bottom line */
430| putchar( ll );
431|
432| for( i = win->x_size-2; --i >= 0 ; )
433| putchar( horiz );
434|
435| putchar( lr );
436| }
437|
438| /*--------------------------------------------------------*/
439|
440| werase( win )
441| WINDOW *win;
442| {
443| vb_scroll( win->x_org, win->x_org + (win->x_size - 1),
444| win->y_org, win->y_org + (win->y_size - 1),
445| win->y_size );
446|
447| cmove( win->y_org, win->x_org );
448| win->row = 0;
449| win->col = 0;
450| }
451|
452| /*----------------------------------------------------------
453| * Scroll the window if scrolling is enabled. Return 1 if we
454| * scrolled. (I'm not sure if the Unix function returns 1
455| * on a scroll but it's convenient to do it here. Don't
456| * assume anything about the return value if you're porting
457| * to Unix. Wscroll() is not a curses function. It lets you
458| * specify a scroll amount and direction (scroll down by -amt
459| * if amt is negative); scroll() is a macro that evaluates to
460| * a wscroll call with an amt of 1. Note that the Unix curses
461| * gets very confused when you scroll explicitly (using
462| * scroll()). In particular, it doesn't clear the bottom line
463| * after a scroll but it thinks that it has. Therefore, when
464| * you try to clear the bottom line, it thinks that there's
465| * nothing there to clear and ignores your wclrtoeol()
466| * commands. Same thing happens when you try to print spaces
467| * to the bottom line; it thinks that spaces are already there
468| * and does nothing. You have to fill the bottom line with
469| * non-space characters of some sort, and then erase it.
470| */
471|
472| wscroll(win, amt)
473| WINDOW *win;
474| {
475| if( win->scroll_ok )
476| doscroll( win->x_org, win->x_org + (win->x_size-1),
477| win->y_org, win->y_org + (win->y_size-1),
478| amt);
479|
480| return win->scroll_ok ;
481| }
482|
483| /*--------------------------------------------------------*/
484|
485| wmove( win, y, x )
486| WINDOW *win;
487| {
488| /* Seek into the window. It's not permitted to seek
489| * outside of the window area.
490| */
491|
492| cmove( win->y_org + (win->row = min(y,win->y_size-1)) ,
493| win->x_org + (win->col = min(x,win->x_size-1)) );
494| }
495|
496| /*--------------------------------------------------------*/
497|
498| static getcon( win )
499| WINDOW *win;
500| {
501| /* Get a character from DOS without echoing. We need
502| * to do this in order to support (echo/noecho). We'll
503| * also do noncrmode input buffering here. Maximum input
504| * line length is 132 columns.
505| *
506| * In nocrmode(), DOS is used to get a line and all the
507| * normal command-line editing functions are available.
508| * Note that since there's no way to turn off echo in
509| * this case, characters will be echoed to the screen
510| * regardles of the status of echo().
511| * In order to retain control of the window, input
512| * fetched for wgetch() is always done in crmode, even
513| * if Crmode isn't set.
514| * If nl() mode is enabled, carriage return (Enter, ^M)
515| * and linefeed (^J) are both mapped to '\n', otherwise
516| * they are not mapped.
517| */
518|
519| static unsigned char buf[ 133 ] = { 133, 0 };
520| static unsigned char *p = buf;
521| static int numchars = 0;
522| register int c;
523|
524| if( Crmode || win )
525| {
526| if( (c = bdos(8,0,0) & 0xff) == ('Z'-'@') )
527| return EOF ;
528|
529| if( c == '\r' && Nl)
530| c = '\n' ;
531|
532| if( Echo )
533| {
534| if( win ) waddch ( win, c );
535| else addch ( c );
536| }
537|
538| return c;
539| }
540| else if( numchars )
541| {
542| --numchars ;
543| return *p++ ;
544| }
545| else
546| {
547| bdos(10, buf, 0);
548| numchars = buf[1];
549| p = &buf[2];
550| }
551| }
552|
553| wgetch (win) WINDOW *win; { return getcon( win ); }
554| getch ( ) { return getcon( NULL ); }
555|
556| /*--------------------------------------------------------*/
557|
558| clear()
559| {
560| doscroll( 0, 79, 0, 24, 25 );
561| move( 0, 0 );
562| }
563|
564| /*--------------------------------------------------------*/
565|
566| wclrtoeol( win )
567| WINDOW *win;
568| {
569| /* Clear from cursor to end of line, the cursor isn't
570| * moved. The main reson that this is included here is
571| * because you have to call it after printing every
572| * newline in order to compensate for a bug in the real
573| * curses. This bug has been corrected in the curses
574| * presented here, however, so you don't have to use
575| * this routine if you're not interested in portability.
576| * Note that you must use a replace function on the
577| * rightmost character to prevent scrolling.
578| */
579|
580| register int i;
581|
582| for( i = win->x_size - win->col - 1; --i >= 0 ;)
583| putchar(' ');
584|
585| replace(' ');
586| cmove( win->y_org + win->row, win->x_org + win->col )
587| }
588|
589| /*--------------------------------------------------------*/
590| #ifdef MAIN
591|
592| WINDOW *boxwin( lines, cols, y_start, x_start )
593| {
594| /* This routine works just like the newwin() except that
595| * the window has a box around it that won't be destoyed
596| * by writes to the window. It accomplishes this feat by
597| * creating two windows, one inside the other, with a box
598| * drawn around the outer one.
599| */
600|
601| WINDOW *outer, *inner;
602|
603| outer = newwin(lines, cols, y_start, x_start);
604|
605| #ifdef MSDOS
606| box( outer, VERT, HORIZ );
607| #else
608| box( outer, '|', '-' );
609| #endif
610|
611| wrefresh ( outer );
612| return newwin( lines-2, cols-2, y_start+1, x_start+1 );
613| }
614|
615| pattern()
616| {
617| clear();
618| printf("01234567890123456789012345678901234567890 0\n");
619| printf("01234567890123456789012345678901234567890 1\n");
620| printf("01234567890123456789012345678901234567890 2\n");
621| printf("01234567890123456789012345678901234567890 3\n");
622| printf("01234567890123456789012345678901234567890 4\n");
623| printf("01234567890123456789012345678901234567890 5\n");
624| printf("01234567890123456789012345678901234567890 6\n");
625| printf("01234567890123456789012345678901234567890 7\n");
626| printf("01234567890123456789012345678901234567890 8\n");
627| printf("01234567890123456789012345678901234567890 9\n");
628| printf("01234567890123456789012345678901234567890 10\n");
629| printf("01234567890123456789012345678901234567890 11\n");
630| printf("01234567890123456789012345678901234567890 12\n");
631| printf("01234567890123456789012345678901234567890 13\n");
632| printf("01234567890123456789012345678901234567890 14\n");
633| printf("01234567890123456789012345678901234567890 15\n");
634| printf("01234567890123456789012345678901234567890 16\n");
635| printf("01234567890123456789012345678901234567890 17\n");
636| printf("01234567890123456789012345678901234567890 18\n");
637| printf("01234567890123456789012345678901234567890 19\n");
638| printf("01234567890123456789012345678901234567890 20\n");
639| printf("01234567890123456789012345678901234567890 21\n");
640| printf("01234567890123456789012345678901234567890 22\n");
641| printf(" 1 2 3 4 n");
642| }
643|
644| main()
645| {
646| /* All coordinates are (y,x) */
647|
648| WINDOW *win1, *win2;
649| char str[128];
650| int c;
651|
652| initscr(); /* Initialize curses */
653| noecho(); /* Echo off (it screws up the screen) */
654| crmode(); /* Put terminal into CBREAK mode */
655|
656| pattern();
657|
658| win1 = boxwin(10, 20, 0, 0 );
659| win2 = boxwin(10, 20, 21, 11);
660|
661| scrollok( win1, TRUE );
662| wprintw(win1, "This is window one, doo wha\n" );
663| wrefresh( win1 );
664| wprintw(win2, "This is window 2.\nPress a key\n" );
665| wrefresh( win2 );
666|
667| c = wgetch(win2);
668| wmove(win1, 5, 0 );
669|
670| wprintw (win1, "Got %c, 0x%x\n", c, c );
671| wrefresh(win1);
672|
673| while( (c = wgetch(win1) & 0x7f) != 'q' )
674| {
675| if( c == 'X'-'@' )
676| wclrtoeol( win1 );
677| else
678| waddch( win1, c );
679|
680| wrefresh( win1 );
681| }
682|
683| move(23,0);
684| refresh();
685| endwin();
686| }
687| #endif
