src/rt/vga.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  vga.c - driver for VGA graphics adaptor under MS-DOS
 */

#include "copyright.h"

#include  "standard.h"

#include  <graph.h>

#include  "driver.h"

#include  "color.h"

#define  GAMMA          2.2             /* exponent for color correction */


int  vga_close(), vga_clear(), vga_paintr(), vga_comout(), vga_errout(),
                vga_comin();

static struct driver  vga_driver = {
        vga_close, vga_clear, vga_paintr, NULL,
        vga_comout, vga_comin, NULL, 1.0
};

static char  fatalerr[128];

static struct videoconfig  config;

extern char  *getenv();


struct driver *
vga_init(name, id)                      /* open VGA */
char  *name, *id;
{
        static short  mode_pref[] = {_MRES256COLOR, -1};
        static short  smode_pref[] = {_XRES256COLOR, _SVRES256COLOR,
                                        _VRES256COLOR, _MRES256COLOR, -1};
        char  *ep;
        register short  *mp;

        mp = !strcmp(name, "vga") ? mode_pref : smode_pref;
        for ( ; *mp != -1; mp++)
                if (_setvideomode(*mp))
                        break;
        if (*mp == -1) {
                _setvideomode(_DEFAULTMODE);
                eputs(name);
                eputs(": card not present or insufficient VGA memory\n");
                return(NULL);
        }
        _getvideoconfig(&config);
        _settextwindow(config.numtextrows-2, 1,
                        config.numtextrows, config.numtextcols);
        vga_driver.xsiz = config.numxpixels;
        vga_driver.ysiz = (long)config.numypixels*(config.numtextrows-3)
                                /config.numtextrows;
        switch (config.mode) {                  /* correct problems */
        case _XRES256COLOR:
                vga_driver.ysiz -= 16;
                break;
        case _MRES256COLOR:
                vga_driver.pixaspect = 1.2;
                break;
        }
        _setviewport(0, 0, vga_driver.xsiz, vga_driver.ysiz);
        if ((ep = getenv("GAMMA")) != NULL)     /* make gamma map */
                make_gmap(atof(ep));
        else
                make_gmap(GAMMA);
        _remappalette(1, _BRIGHTWHITE);
        _settextcolor(1);
        ms_gcinit(&vga_driver);
        erract[USER].pf =
        erract[SYSTEM].pf =
        erract[INTERNAL].pf =
        erract[CONSISTENCY].pf = vga_errout;
        erract[COMMAND].pf = vga_comout;
        if (erract[WARNING].pf != NULL)
                erract[WARNING].pf = vga_comout;
        return(&vga_driver);
}


static
vga_close()                                     /* close VGA */
{
        ms_gcdone(&vga_driver);
        _setvideomode(_DEFAULTMODE);
        erract[USER].pf =                       /* reset error vector */
        erract[SYSTEM].pf =
        erract[INTERNAL].pf =
        erract[CONSISTENCY].pf = eputs;
        erract[COMMAND].pf = NULL;
        if (erract[WARNING].pf != NULL)
                erract[WARNING].pf = wputs;
        if (fatalerr[0])
                eputs(fatalerr);                /* repeat error message */
}


static
vga_clear(x, y)                                 /* clear VGA */
int  x, y;
{
        _clearscreen(_GCLEARSCREEN);
        new_ctab(config.numcolors-2);           /* init color table */
}


static
vga_paintr(col, xmin, ymin, xmax, ymax)         /* paint a rectangle */
COLOR  col;
int  xmin, ymin, xmax, ymax;
{
        extern int  vgacolr();

        _setcolor(get_pixel(col, vgacolr)+2);
        _rectangle(_GFILLINTERIOR, xmin, vga_driver.ysiz-ymax,
                        xmax-1, vga_driver.ysiz-1-ymin);
        vga_driver.inpready = kbhit();
}


static
vga_comout(s)                           /* put s to text output */
register char  *s;
{
        struct rccoord  tpos;
        char  buf[128];
        register char  *cp;

        for (cp = buf; ; s++) {
                switch (*s) {
                case '\b':
                case '\r':
                case '\0':
                        if (cp > buf) {
                                *cp = '\0';
                                _outtext(cp = buf);
                        }
                        if (*s == '\0')
                                break;
                        tpos = _gettextposition();
                        _settextposition(tpos.row, *s=='\r' ? 1 : tpos.col-1);
                        continue;
                default:
                        *cp++ = *s;
                        continue;
                }
                return(0);
        }
        fatalerr[0] = '\0';
}


static
vga_errout(msg)
register char  *msg;
{
        static char  *fep = fatalerr;

        _outtext(msg);
        while (*msg)
                *fep++ = *msg++;
        *fep = '\0';
        if (fep > fatalerr && fep[-1] == '\n')
                fep = fatalerr;
}


static
vga_comin(buf, prompt)                  /* get input line from console */
char  *buf;
char  *prompt;
{
        extern int  getch();

        if (prompt != NULL)
                _outtext(prompt);
        editline(buf, getch, vga_comout);
        vga_driver.inpready = kbhit();
}


static
vgacolr(index, r, g, b)                /* enter a color into our table */
int  index;
int  r, g, b;
{
        register long  cl;

        cl = (long)b<<14 & 0x3f0000L;
        cl |= g<<6 & 0x3f00;
        cl |= r>>2;
        _remappalette(index+2, cl);
}
Revision:	2.9
Committed:	Tue Feb 25 02:47:23 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 2.8:	+1 -56 lines
Log Message:	Replaced inline copyright notice with #include "copyright.h"
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.8	static const char RCSid[] = "$Id$";
3	greg	2.1	#endif
4			/*
5			* vga.c - driver for VGA graphics adaptor under MS-DOS
6	greg	2.8	*/
7
8	greg	2.9	#include "copyright.h"
9	greg	2.1
10	gregl	2.7	#include "standard.h"
11	greg	2.1
12			#include <graph.h>
13
14			#include "driver.h"
15
16			#include "color.h"
17
18			#define GAMMA 2.2 /* exponent for color correction */
19
20
21	greg	2.2	int vga_close(), vga_clear(), vga_paintr(), vga_comout(), vga_errout(),
22			vga_comin();
23	greg	2.1
24			static struct driver vga_driver = {
25			vga_close, vga_clear, vga_paintr, NULL,
26	greg	2.2	vga_comout, vga_comin, NULL, 1.0
27	greg	2.1	};
28
29	greg	2.2	static char fatalerr[128];
30
31	greg	2.1	static struct videoconfig config;
32
33	greg	2.2	extern char *getenv();
34	greg	2.1
35	greg	2.2
36	greg	2.1	struct driver *
37			vga_init(name, id) /* open VGA */
38			char name, id;
39			{
40	greg	2.4	static short mode_pref[] = {_MRES256COLOR, -1};
41			static short smode_pref[] = {_XRES256COLOR, _SVRES256COLOR,
42	greg	2.3	_VRES256COLOR, _MRES256COLOR, -1};
43	greg	2.2	char *ep;
44	greg	2.4	register short *mp;
45	greg	2.2
46	greg	2.4	mp = !strcmp(name, "vga") ? mode_pref : smode_pref;
47			for ( ; *mp != -1; mp++)
48			if (_setvideomode(*mp))
49	greg	2.2	break;
50	greg	2.4	if (*mp == -1) {
51	greg	2.2	_setvideomode(_DEFAULTMODE);
52	gregl	2.7	eputs(name);
53			eputs(": card not present or insufficient VGA memory\n");
54	greg	2.1	return(NULL);
55	greg	2.2	}
56	greg	2.1	_getvideoconfig(&config);
57			_settextwindow(config.numtextrows-2, 1,
58			config.numtextrows, config.numtextcols);
59			vga_driver.xsiz = config.numxpixels;
60	greg	2.2	vga_driver.ysiz = (long)config.numypixels*(config.numtextrows-3)
61	greg	2.1	/config.numtextrows;
62	greg	2.2	switch (config.mode) { /* correct problems */
63			case _XRES256COLOR:
64			vga_driver.ysiz -= 16;
65			break;
66			case _MRES256COLOR:
67			vga_driver.pixaspect = 1.2;
68			break;
69			}
70	greg	2.1	_setviewport(0, 0, vga_driver.xsiz, vga_driver.ysiz);
71	greg	2.2	if ((ep = getenv("GAMMA")) != NULL) /* make gamma map */
72			make_gmap(atof(ep));
73			else
74			make_gmap(GAMMA);
75			_remappalette(1, _BRIGHTWHITE);
76	greg	2.1	_settextcolor(1);
77	greg	2.2	ms_gcinit(&vga_driver);
78	gregl	2.7	erract[USER].pf =
79			erract[SYSTEM].pf =
80			erract[INTERNAL].pf =
81			erract[CONSISTENCY].pf = vga_errout;
82			erract[COMMAND].pf = vga_comout;
83			if (erract[WARNING].pf != NULL)
84			erract[WARNING].pf = vga_comout;
85	greg	2.1	return(&vga_driver);
86			}
87
88
89			static
90			vga_close() /* close VGA */
91			{
92	greg	2.5	ms_gcdone(&vga_driver);
93	greg	2.2	_setvideomode(_DEFAULTMODE);
94	gregl	2.7	erract[USER].pf = /* reset error vector */
95			erract[SYSTEM].pf =
96			erract[INTERNAL].pf =
97			erract[CONSISTENCY].pf = eputs;
98			erract[COMMAND].pf = NULL;
99			if (erract[WARNING].pf != NULL)
100			erract[WARNING].pf = wputs;
101	greg	2.2	if (fatalerr[0])
102	gregl	2.7	eputs(fatalerr); /* repeat error message */
103	greg	2.1	}
104
105
106			static
107			vga_clear(x, y) /* clear VGA */
108			int x, y;
109			{
110			_clearscreen(_GCLEARSCREEN);
111			new_ctab(config.numcolors-2); /* init color table */
112			}
113
114
115			static
116			vga_paintr(col, xmin, ymin, xmax, ymax) /* paint a rectangle */
117			COLOR col;
118			int xmin, ymin, xmax, ymax;
119			{
120			extern int vgacolr();
121
122			_setcolor(get_pixel(col, vgacolr)+2);
123			_rectangle(_GFILLINTERIOR, xmin, vga_driver.ysiz-ymax,
124			xmax-1, vga_driver.ysiz-1-ymin);
125			vga_driver.inpready = kbhit();
126			}
127
128
129			static
130			vga_comout(s) /* put s to text output */
131			register char *s;
132			{
133			struct rccoord tpos;
134			char buf[128];
135			register char *cp;
136
137			for (cp = buf; ; s++) {
138			switch (*s) {
139			case '\b':
140			case '\r':
141			case '\0':
142			if (cp > buf) {
143			*cp = '\0';
144			_outtext(cp = buf);
145			}
146			if (*s == '\0')
147			break;
148			tpos = _gettextposition();
149	greg	2.2	_settextposition(tpos.row, *s=='\r' ? 1 : tpos.col-1);
150	greg	2.1	continue;
151			default:
152			cp++ = s;
153			continue;
154			}
155			return(0);
156			}
157	greg	2.2	fatalerr[0] = '\0';
158			}
159
160
161			static
162			vga_errout(msg)
163			register char *msg;
164			{
165			static char *fep = fatalerr;
166
167			_outtext(msg);
168			while (*msg)
169			fep++ = msg++;
170			*fep = '\0';
171			if (fep > fatalerr && fep[-1] == '\n')
172			fep = fatalerr;
173	greg	2.1	}
174
175
176			static
177			vga_comin(buf, prompt) /* get input line from console */
178			char *buf;
179			char *prompt;
180			{
181			extern int getch();
182
183			if (prompt != NULL)
184			_outtext(prompt);
185			editline(buf, getch, vga_comout);
186			vga_driver.inpready = kbhit();
187			}
188
189
190			static
191			vgacolr(index, r, g, b) /* enter a color into our table */
192			int index;
193			int r, g, b;
194			{
195			register long cl;
196
197			cl = (long)b<<14 & 0x3f0000L;
198			cl \|= g<<6 & 0x3f00;
199			cl \|= r>>2;
200			_remappalette(index+2, cl);
201			}