src/rt/vga.c

/* Copyright (c) 1992 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  vga.c - driver for VGA graphics adaptor under MS-DOS
 */

#include  <stdio.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[] = {_XRES256COLOR, _SVRES256COLOR,
                                        _VRES256COLOR, _MRES256COLOR, -1};
        char  *ep;
        register int  i;

        for (i = 0; mode_pref[i] != -1; i++)
                if (_setvideomode(mode_pref[i]))
                        break;
        if (mode_pref[i] == -1) {
                _setvideomode(_DEFAULTMODE);
                stderr_v(name);
                stderr_v(": 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);
        errvec = vga_errout;
        cmdvec = vga_comout;
        if (wrnvec != NULL)
                wrnvec = vga_comout;
        return(&vga_driver);
}


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