783 lines
18 KiB
C
783 lines
18 KiB
C
/*
|
|
* Copyright (c) 1992, 2000 Hellmuth Michaelis
|
|
*
|
|
* Copyright (c) 1992, 1994 Joerg Wunsch
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
*
|
|
* scon - screen control utility for pcvt
|
|
* --------------------------------------
|
|
*
|
|
* Last Edit-Date: [Mon Mar 27 17:19:34 2000]
|
|
*
|
|
* $FreeBSD$
|
|
*
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#include <stdio.h>
|
|
#include <err.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <machine/pcvt_ioctl.h>
|
|
|
|
#define DEFAULTFD 0
|
|
|
|
int aflag = -1;
|
|
int lflag = -1;
|
|
int mflag = -1;
|
|
int current = -1;
|
|
int pflag = -1;
|
|
int hflag = -1;
|
|
int res = -1;
|
|
char *device;
|
|
int dflag = -1;
|
|
int vflag = 0;
|
|
int Pflag = 0;
|
|
int tflag = 0;
|
|
int fflag = -1;
|
|
int colms = 0;
|
|
char *onoff;
|
|
|
|
unsigned timeout;
|
|
struct screeninfo screeninfo;
|
|
|
|
#define NVGAPEL 256
|
|
|
|
struct rgb {
|
|
unsigned r, g, b;
|
|
int dothis;
|
|
};
|
|
|
|
static struct rgb palette[NVGAPEL] = {
|
|
{ 0x00, 0x00, 0x00, 0}, /* 0 - black */
|
|
{ 0x00, 0x00, 0x2a, 0}, /* 1 - blue */
|
|
{ 0x00, 0x2a, 0x00, 0}, /* 2 - green */
|
|
{ 0x00, 0x2a, 0x2a, 0}, /* 3 - cyan */
|
|
{ 0x2a, 0x00, 0x00, 0}, /* 4 - red */
|
|
{ 0x2a, 0x00, 0x2a, 0}, /* 5 - magenta */
|
|
{ 0x2a, 0x2a, 0x00, 0}, /* 6 */
|
|
{ 0x2a, 0x2a, 0x2a, 0}, /* 7 - lightgray */
|
|
{ 0x00, 0x00, 0x15, 0}, /* 8 */
|
|
{ 0x00, 0x00, 0x3f, 0}, /* 9 */
|
|
{ 0x00, 0x2a, 0x15, 0}, /* 10 */
|
|
{ 0x00, 0x2a, 0x3f, 0}, /* 11 */
|
|
{ 0x2a, 0x00, 0x15, 0}, /* 12 */
|
|
{ 0x2a, 0x00, 0x3f, 0}, /* 13 */
|
|
{ 0x2a, 0x2a, 0x15, 0}, /* 14 */
|
|
{ 0x2a, 0x2a, 0x3f, 0}, /* 15 */
|
|
{ 0x00, 0x15, 0x00, 0}, /* 16 */
|
|
{ 0x00, 0x15, 0x2a, 0}, /* 17 */
|
|
{ 0x00, 0x3f, 0x00, 0}, /* 18 */
|
|
{ 0x00, 0x3f, 0x2a, 0}, /* 19 */
|
|
{ 0x2a, 0x15, 0x00, 0}, /* 20 - brown */
|
|
{ 0x2a, 0x15, 0x2a, 0}, /* 21 */
|
|
{ 0x2a, 0x3f, 0x00, 0}, /* 22 */
|
|
{ 0x2a, 0x3f, 0x2a, 0}, /* 23 */
|
|
{ 0x00, 0x15, 0x15, 0}, /* 24 */
|
|
{ 0x00, 0x15, 0x3f, 0}, /* 25 */
|
|
{ 0x00, 0x3f, 0x15, 0}, /* 26 */
|
|
{ 0x00, 0x3f, 0x3f, 0}, /* 27 */
|
|
{ 0x2a, 0x15, 0x15, 0}, /* 28 */
|
|
{ 0x2a, 0x15, 0x3f, 0}, /* 29 */
|
|
{ 0x2a, 0x3f, 0x15, 0}, /* 30 */
|
|
{ 0x2a, 0x3f, 0x3f, 0}, /* 31 */
|
|
{ 0x15, 0x00, 0x00, 0}, /* 32 */
|
|
{ 0x15, 0x00, 0x2a, 0}, /* 33 */
|
|
{ 0x15, 0x2a, 0x00, 0}, /* 34 */
|
|
{ 0x15, 0x2a, 0x2a, 0}, /* 35 */
|
|
{ 0x3f, 0x00, 0x00, 0}, /* 36 */
|
|
{ 0x3f, 0x00, 0x2a, 0}, /* 37 */
|
|
{ 0x3f, 0x2a, 0x00, 0}, /* 38 */
|
|
{ 0x3f, 0x2a, 0x2a, 0}, /* 39 */
|
|
{ 0x15, 0x00, 0x15, 0}, /* 40 */
|
|
{ 0x15, 0x00, 0x3f, 0}, /* 41 */
|
|
{ 0x15, 0x2a, 0x15, 0}, /* 42 */
|
|
{ 0x15, 0x2a, 0x3f, 0}, /* 43 */
|
|
{ 0x3f, 0x00, 0x15, 0}, /* 44 */
|
|
{ 0x3f, 0x00, 0x3f, 0}, /* 45 */
|
|
{ 0x3f, 0x2a, 0x15, 0}, /* 46 */
|
|
{ 0x3f, 0x2a, 0x3f, 0}, /* 47 */
|
|
{ 0x15, 0x15, 0x00, 0}, /* 48 */
|
|
{ 0x15, 0x15, 0x2a, 0}, /* 49 */
|
|
{ 0x15, 0x3f, 0x00, 0}, /* 50 */
|
|
{ 0x15, 0x3f, 0x2a, 0}, /* 51 */
|
|
{ 0x3f, 0x15, 0x00, 0}, /* 52 */
|
|
{ 0x3f, 0x15, 0x2a, 0}, /* 53 */
|
|
{ 0x3f, 0x3f, 0x00, 0}, /* 54 */
|
|
{ 0x3f, 0x3f, 0x2a, 0}, /* 55 */
|
|
{ 0x15, 0x15, 0x15, 0}, /* 56 - darkgray */
|
|
{ 0x15, 0x15, 0x3f, 0}, /* 57 - lightblue */
|
|
{ 0x15, 0x3f, 0x15, 0}, /* 58 - lightgreen */
|
|
{ 0x15, 0x3f, 0x3f, 0}, /* 59 - lightcyan */
|
|
{ 0x3f, 0x15, 0x15, 0}, /* 60 - lightred */
|
|
{ 0x3f, 0x15, 0x3f, 0}, /* 61 - lightmagenta */
|
|
{ 0x3f, 0x3f, 0x15, 0}, /* 62 - yellow */
|
|
{ 0x3f, 0x3f, 0x3f, 0}, /* 63 - white */
|
|
{ 0x00, 0x00, 0x00, 0} /* 64 ... - empty */
|
|
};
|
|
|
|
static struct colname {
|
|
const char *name;
|
|
unsigned idx;
|
|
} colnames[] = {
|
|
{"black", 0},
|
|
{"blue", 1},
|
|
{"green", 2},
|
|
{"cyan", 3},
|
|
{"red", 4},
|
|
{"magenta", 5},
|
|
{"brown", 20},
|
|
{"lightgray", 7},
|
|
{"lightgrey", 7},
|
|
{"darkgray", 56},
|
|
{"darkgrey", 56},
|
|
{"lightblue", 57},
|
|
{"lightgreen", 58},
|
|
{"lightcyan", 59},
|
|
{"lightred", 60},
|
|
{"lightmagenta", 61},
|
|
{"yellow", 62},
|
|
{"white", 63},
|
|
/* must be terminator: */ {(const char *)NULL, 0}
|
|
};
|
|
|
|
|
|
static void parsepopt(char *arg, unsigned *idx,
|
|
unsigned *r, unsigned *g, unsigned *b);
|
|
static void printpalette(int fd);
|
|
|
|
main(argc,argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
int c;
|
|
int fd;
|
|
|
|
while( (c = getopt(argc, argv, "ac:d:f:HVlms:t:vp:18")) != -1)
|
|
{
|
|
switch(c)
|
|
{
|
|
case 'a':
|
|
aflag = 1;
|
|
break;
|
|
|
|
case 'l':
|
|
lflag = 1;
|
|
break;
|
|
|
|
case 'm':
|
|
mflag = 1;
|
|
break;
|
|
|
|
case 'c':
|
|
current = atoi(optarg);
|
|
break;
|
|
|
|
case 'd':
|
|
device = optarg;
|
|
dflag = 1;
|
|
break;
|
|
|
|
case 'f':
|
|
onoff = optarg;
|
|
fflag = 1;
|
|
break;
|
|
|
|
case 'V':
|
|
pflag = 1;
|
|
break;
|
|
|
|
case 'H':
|
|
hflag = 1;
|
|
break;
|
|
|
|
case 's':
|
|
if (!strncmp(optarg, "25", 2))
|
|
res = SIZ_25ROWS;
|
|
else if(!strncmp(optarg, "28", 2))
|
|
res = SIZ_28ROWS;
|
|
else if(!strncmp(optarg, "35", 2))
|
|
res = SIZ_35ROWS;
|
|
else if(!strncmp(optarg, "40", 2))
|
|
res = SIZ_40ROWS;
|
|
else if(!strncmp(optarg, "43", 2))
|
|
res = SIZ_43ROWS;
|
|
else if(!strncmp(optarg, "50", 2))
|
|
res = SIZ_50ROWS;
|
|
break;
|
|
|
|
case 'v':
|
|
vflag++;
|
|
break;
|
|
|
|
case 'p':
|
|
if(!strcmp(optarg, "list"))
|
|
{
|
|
if(Pflag)
|
|
errx(2, "-p list is mutual exclusive with other -p options");
|
|
Pflag = 3;
|
|
}
|
|
else if(!strcmp(optarg, "default"))
|
|
{
|
|
if(Pflag)
|
|
errx(2, "multiple -p default not allowed");
|
|
Pflag = 2;
|
|
} else {
|
|
unsigned idx, r, g, b;
|
|
|
|
if(Pflag > 1)
|
|
errx(2, "-p default and -p i,r,g,b ambiguous");
|
|
Pflag = 1;
|
|
parsepopt(optarg, &idx, &r, &g, &b);
|
|
if(idx >= NVGAPEL)
|
|
errx(2, "index %u in -p option out of range", idx);
|
|
palette[idx].r = r;
|
|
palette[idx].g = g;
|
|
palette[idx].b = b;
|
|
palette[idx].dothis = 1;
|
|
}
|
|
break;
|
|
|
|
case 't':
|
|
tflag++;
|
|
timeout = atoi(optarg);
|
|
break;
|
|
|
|
case '1':
|
|
colms = 132;
|
|
break;
|
|
|
|
case '8':
|
|
colms = 80;
|
|
break;
|
|
|
|
case '?':
|
|
default:
|
|
usage();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if((pflag == 1) && (hflag == 1))
|
|
usage();
|
|
|
|
if(dflag == -1 && lflag == -1 && current == -1 && pflag == -1 &&
|
|
hflag == -1 && res == -1 && Pflag == 0 && tflag == 0 && fflag == -1
|
|
&& colms == 0 && mflag == -1)
|
|
{
|
|
lflag = 1;
|
|
}
|
|
|
|
if(dflag == -1)
|
|
{
|
|
if(vflag)
|
|
printf("using current device\n");
|
|
fd = DEFAULTFD; /* -hm, Feb 12 1993 */
|
|
}
|
|
else
|
|
{
|
|
if((fd = open(device, O_RDWR)) == -1)
|
|
err(1, "ERROR opening %s", device);
|
|
if(vflag)
|
|
printf("using device %s\n",device);
|
|
}
|
|
|
|
if(aflag == 1) /* return adaptor type */
|
|
{
|
|
printadaptor(fd);
|
|
exit(0);
|
|
}
|
|
|
|
if(mflag == 1) /* return monitor type */
|
|
{
|
|
printmonitor(fd);
|
|
exit(0);
|
|
}
|
|
|
|
if(lflag == 1) /* list information */
|
|
{
|
|
if(vflag)
|
|
printf("processing option -l, listing screen info\n");
|
|
printinfo(fd);
|
|
exit(0);
|
|
}
|
|
|
|
if(tflag) /* set screen saver timeout */
|
|
{
|
|
if(vflag)
|
|
{
|
|
printf(
|
|
"processing option -t, setting screen saver timeout: "
|
|
);
|
|
if(timeout)
|
|
printf("new timeout = %d s\n", timeout);
|
|
else
|
|
printf("turned off\n");
|
|
}
|
|
|
|
if(ioctl(fd, VGASCREENSAVER, &timeout) < 0)
|
|
{
|
|
warn("ioctl(VGASCREENSAVER)");
|
|
fprintf(stderr, "Check the driver, the screensaver is probably not compiled in!\n");
|
|
exit(2);
|
|
}
|
|
goto success;
|
|
}
|
|
|
|
if(colms)
|
|
{
|
|
if(vflag)
|
|
printf("Setting number of columns to %d\n", colms);
|
|
if(ioctl(fd, VGASETCOLMS, &colms) < 0)
|
|
err(2, "ioctl(VGASETCOLMS)");
|
|
goto success;
|
|
}
|
|
|
|
if(Pflag == 3)
|
|
{
|
|
/* listing VGA palette */
|
|
if(vflag)
|
|
printf("processing option -p list, "
|
|
"listing VGA palette\n");
|
|
|
|
printpalette(fd);
|
|
goto success;
|
|
}
|
|
|
|
if(Pflag)
|
|
{
|
|
unsigned int idx;
|
|
|
|
/* setting VGA palette */
|
|
if(vflag)
|
|
printf("processing option -p, setting VGA palette%s\n",
|
|
Pflag == 2? " to default": "");
|
|
|
|
for(idx = 0; idx < NVGAPEL; idx++)
|
|
if(Pflag == 2 || palette[idx].dothis)
|
|
{
|
|
struct vgapel p;
|
|
p.idx = idx;
|
|
p.r = palette[idx].r;
|
|
p.g = palette[idx].g;
|
|
p.b = palette[idx].b;
|
|
if(ioctl(fd, VGAWRITEPEL, (caddr_t)&p) < 0)
|
|
err(2, "ioctl(fd, VGAWRITEPEL)");
|
|
}
|
|
goto success;
|
|
}
|
|
|
|
screeninfo.screen_no = -1; /* We are using fd */
|
|
screeninfo.current_screen = current;
|
|
screeninfo.pure_vt_mode = -1;
|
|
screeninfo.screen_size = res;
|
|
screeninfo.force_24lines = -1;
|
|
|
|
if(current != -1) /* set current screen */
|
|
{
|
|
if(vflag)
|
|
printf("processing option -c, setting current screen to %d\n",current);
|
|
|
|
if(ioctl(1, VGASETSCREEN, &screeninfo) == -1)
|
|
err(1, "ioctl VGASETSCREEN failed");
|
|
exit(0);
|
|
}
|
|
|
|
if(pflag == 1)
|
|
{
|
|
if(vflag)
|
|
printf("processing option -V, setting emulation to pure VT220\n");
|
|
screeninfo.pure_vt_mode = M_PUREVT;
|
|
}
|
|
else if(hflag == 1)
|
|
{
|
|
if(vflag)
|
|
printf("processing option -H, setting emulation to VT220 + HP Labels\n");
|
|
screeninfo.pure_vt_mode = M_HPVT;
|
|
}
|
|
else
|
|
{
|
|
if(vflag)
|
|
printf("no change in terminal emulation\n");
|
|
}
|
|
|
|
if(vflag)
|
|
{
|
|
if(res == -1)
|
|
printf("no change in screen resolution\n");
|
|
else if(res == SIZ_25ROWS)
|
|
printf("change screen resolution to 25 lines\n");
|
|
else if(res == SIZ_28ROWS)
|
|
printf("change screen resolution to 28 lines\n");
|
|
else if(res == SIZ_35ROWS)
|
|
printf("change screen resolution to 35 lines\n");
|
|
else if(res == SIZ_40ROWS)
|
|
printf("change screen resolution to 40 lines\n");
|
|
else if(res == SIZ_43ROWS)
|
|
printf("change screen resolution to 43 lines\n");
|
|
else if(res == SIZ_50ROWS)
|
|
printf("change screen resolution to 50 lines\n");
|
|
}
|
|
|
|
if(fflag == 1) /* force 24 lines on/off */
|
|
{
|
|
if(!strcmp(onoff, "on"))
|
|
{
|
|
fflag = 1;
|
|
}
|
|
else if(!strcmp(onoff, "off"))
|
|
{
|
|
fflag = 0;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr,"you must specify 'on' or 'off' with -f option!\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
screeninfo.force_24lines = fflag;
|
|
|
|
if(ioctl(fd, VGASETSCREEN, &screeninfo) == -1)
|
|
err(1, "ioctl VGASETSCREEN failed");
|
|
success:
|
|
if(vflag)
|
|
printf("successful execution of ioctl VGASETSCREEN!\n");
|
|
exit(0);
|
|
}
|
|
|
|
usage()
|
|
{
|
|
fprintf(stderr,"\nscon - screen control utility for the pcvt video driver\n");
|
|
fprintf(stderr,"usage: scon -a -l -m -v -c [n] -d [dev] -f [on|off] -V -H -s [n]\n");
|
|
fprintf(stderr,"usage: scon -p [default | list | i,r,g,b] | -t [sec] | -1 | -8\n");
|
|
fprintf(stderr," -a list video adaptor type (MDA,CGA,EGA or VGA)\n");
|
|
fprintf(stderr," -c <screen no> switch current virtual screen to <screen no>\n");
|
|
fprintf(stderr," -d <device> set parameters(-V|-H|-s) for virtual device\n");
|
|
fprintf(stderr," -f <on|off> force 24 lines in VT 25 lines and HP 28 lines mode\n");
|
|
fprintf(stderr," -H set VT220/HP emulation mode for a virtual screen\n");
|
|
fprintf(stderr," -l list current parameters for a virtual screen\n");
|
|
fprintf(stderr," -m report monitor type (MONO/COLOR)\n");
|
|
fprintf(stderr," -p default set default VGA palette\n");
|
|
fprintf(stderr," -p list list current VGA palette\n");
|
|
fprintf(stderr," -p <i,r,g,b> set VGA palette entry i to r/g/b\n");
|
|
fprintf(stderr," -p <name,r,g,b> set VGA palette entry for color name to r/g/b\n");
|
|
fprintf(stderr," -s <lines> set 25, 28, 35, 40, 43 or 50 lines for a virtual screen\n");
|
|
fprintf(stderr," -t <timeout> set screen saver timeout [seconds]\n");
|
|
fprintf(stderr," -1 set 132 columns mode\n");
|
|
fprintf(stderr," -8 set 80 columns mode\n");
|
|
fprintf(stderr," -v verbose mode\n");
|
|
fprintf(stderr," -V set pure VT220 emulation for a virtual screen\n");
|
|
fprintf(stderr," -? display help (this message)\n\n");
|
|
exit(1);
|
|
}
|
|
|
|
printadaptor(fd)
|
|
int fd;
|
|
{
|
|
if(ioctl(fd, VGAGETSCREEN, &screeninfo) == -1)
|
|
err(1, "ioctl VGAGETSCREEN failed");
|
|
switch(screeninfo.adaptor_type)
|
|
{
|
|
default:
|
|
case UNKNOWN_ADAPTOR:
|
|
printf("UNKNOWN\n");
|
|
break;
|
|
|
|
case MDA_ADAPTOR:
|
|
printf("MDA\n");
|
|
break;
|
|
|
|
case CGA_ADAPTOR:
|
|
printf("CGA\n");
|
|
break;
|
|
|
|
case EGA_ADAPTOR:
|
|
printf("EGA\n");
|
|
break;
|
|
|
|
case VGA_ADAPTOR:
|
|
printf("VGA\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
printmonitor(fd)
|
|
int fd;
|
|
{
|
|
if(ioctl(fd, VGAGETSCREEN, &screeninfo) == -1)
|
|
err(1, "ioctl VGAGETSCREEN failed");
|
|
switch(screeninfo.monitor_type)
|
|
{
|
|
default:
|
|
printf("UNKNOWN\n");
|
|
break;
|
|
|
|
case MONITOR_MONO:
|
|
printf("MONO\n");
|
|
break;
|
|
|
|
case MONITOR_COLOR:
|
|
printf("COLOR\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
char *vga_type(int number)
|
|
{
|
|
static char *vga_tab[] = {
|
|
"Generic VGA",
|
|
"ET4000",
|
|
"ET3000",
|
|
"PVGA1A",
|
|
"WD90C00",
|
|
"WD90C10",
|
|
"WD90C11",
|
|
"VIDEO 7 VEGA",
|
|
"VIDEO 7 FAST",
|
|
"VIDEO 7 VER5",
|
|
"VIDEO 7 1024I",
|
|
"Unknown VIDEO 7",
|
|
"TVGA 8800BR",
|
|
"TVGA 8800CS",
|
|
"TVGA 8900B",
|
|
"TVGA 8900C",
|
|
"TVGA 8900CL",
|
|
"TVGA 9000",
|
|
"TVGA 9100",
|
|
"TVGA 9200",
|
|
"Unknown TRIDENT",
|
|
"S3 80C911",
|
|
"S3 80C924",
|
|
"S3 80C801/80C805",
|
|
"S3 80C928",
|
|
"Unknown S3",
|
|
"CL-GD5402",
|
|
"CL-GD5402r1",
|
|
"CL-GD5420",
|
|
"CL-GD5420r1",
|
|
"CL-GD5422",
|
|
"CL-GD5424",
|
|
"CL-GD5426",
|
|
"CL-GD5428",
|
|
|
|
};
|
|
return(vga_tab[number]);
|
|
}
|
|
|
|
char *vga_family(int number)
|
|
{
|
|
static char *vga_tab[] = {
|
|
"Generic VGA",
|
|
"Tseng Labs",
|
|
"Western Digital",
|
|
"Video Seven",
|
|
"Trident",
|
|
"S3 Incorporated",
|
|
"Cirrus Logic",
|
|
};
|
|
return(vga_tab[number]);
|
|
}
|
|
|
|
printinfo(fd)
|
|
int fd;
|
|
{
|
|
if(ioctl(fd, VGAGETSCREEN, &screeninfo) == -1)
|
|
err(1, "ioctl VGAGETSCREEN failed");
|
|
|
|
printf( "\nVideo Adaptor Type = ");
|
|
|
|
switch(screeninfo.adaptor_type)
|
|
{
|
|
default:
|
|
case UNKNOWN_ADAPTOR:
|
|
printf("UNKNOWN Video Adaptor\n");
|
|
break;
|
|
|
|
case MDA_ADAPTOR:
|
|
printf("MDA - Monochrome Display Adaptor\n");
|
|
break;
|
|
|
|
case CGA_ADAPTOR:
|
|
printf("CGA - Color Graphics Adaptor\n");
|
|
break;
|
|
|
|
case EGA_ADAPTOR:
|
|
printf("EGA - Enhanced Graphics Adaptor\n");
|
|
break;
|
|
|
|
case VGA_ADAPTOR:
|
|
printf("VGA - Video Graphics Adaptor/Array\n");
|
|
printf(" VGA Chipset Manufacturer = %s\n",
|
|
vga_family(screeninfo.vga_family));
|
|
printf(" VGA Chipset Type = %s\n",
|
|
vga_type(screeninfo.vga_type));
|
|
printf(" Support for 132 Column Mode = %s\n",
|
|
screeninfo.vga_132 ? "Yes" : "No");
|
|
break;
|
|
}
|
|
|
|
printf( "Display Monitor Type = ");
|
|
|
|
switch(screeninfo.monitor_type)
|
|
{
|
|
default:
|
|
printf("UNKNOWN Monitor Type\n");
|
|
break;
|
|
|
|
case MONITOR_MONO:
|
|
printf("Monochrome Monitor\n");
|
|
break;
|
|
|
|
case MONITOR_COLOR:
|
|
printf("Color Monitor\n");
|
|
break;
|
|
}
|
|
|
|
printf( "Number of Downloadable Fonts = %d\n",screeninfo.totalfonts);
|
|
printf( "Number of Virtual Screens = %d\n",screeninfo.totalscreens);
|
|
printf( "Info Request Screen Number = %d\n",screeninfo.screen_no);
|
|
printf( "Current Displayed Screen = %d\n",screeninfo.current_screen);
|
|
|
|
if(screeninfo.pure_vt_mode == M_PUREVT)
|
|
printf( "Terminal Emulation Mode = VT220\n");
|
|
else
|
|
printf( "Terminal Emulation Mode = VT220 with HP Features\n");
|
|
|
|
printf( "Lines = ");
|
|
|
|
switch(screeninfo.screen_size)
|
|
{
|
|
case SIZ_25ROWS:
|
|
printf( "25\n");
|
|
break;
|
|
|
|
case SIZ_28ROWS:
|
|
printf( "28\n");
|
|
break;
|
|
|
|
case SIZ_35ROWS:
|
|
printf( "35\n");
|
|
break;
|
|
|
|
case SIZ_40ROWS:
|
|
printf( "40\n");
|
|
break;
|
|
|
|
case SIZ_43ROWS:
|
|
printf( "43\n");
|
|
break;
|
|
|
|
case SIZ_50ROWS:
|
|
printf( "50\n");
|
|
break;
|
|
|
|
default:
|
|
printf( "UNKNOWN\n");
|
|
break;
|
|
}
|
|
printf( "Force 24 Lines = %s",
|
|
screeninfo.force_24lines ? "Yes" : "No");
|
|
|
|
printf("\n\n");
|
|
}
|
|
|
|
static const char *findname(unsigned idx)
|
|
{
|
|
/* try to find a name for palette entry idx */
|
|
/* if multiple names exist, returns first matching */
|
|
register struct colname *cnp;
|
|
|
|
for(cnp = colnames; cnp->name; cnp++)
|
|
if(cnp->idx == idx)
|
|
return cnp->name;
|
|
|
|
/* not found */
|
|
return (const char *)NULL;
|
|
}
|
|
|
|
static void printpalette(int fd)
|
|
{
|
|
register unsigned idx, last;
|
|
|
|
for(idx = 0; idx < NVGAPEL; idx++)
|
|
{
|
|
struct vgapel p;
|
|
p.idx = idx;
|
|
if(ioctl(fd, VGAREADPEL, &p) < 0)
|
|
err(2, "ioctl(VGAREADPEL)");
|
|
palette[idx].r = p.r;
|
|
palette[idx].g = p.g;
|
|
palette[idx].b = p.b;
|
|
}
|
|
|
|
/* find last non-empty entry */
|
|
for(last = NVGAPEL - 1; last; last--)
|
|
if(palette[last].r || palette[last].g || palette[last].b)
|
|
break;
|
|
|
|
if(last != NVGAPEL - 1)
|
|
last++;
|
|
|
|
/* now, everything's collected. print out table */
|
|
printf("VGA palette status\n");
|
|
printf("index red green blue name\n");
|
|
for(idx = 0; idx < last; idx++)
|
|
{
|
|
const char *cp;
|
|
printf("%5d %5d %5d %5d",
|
|
idx, palette[idx].r, palette[idx].g, palette[idx].b);
|
|
if(cp = findname(idx))
|
|
printf(" %s\n", cp);
|
|
else
|
|
putchar('\n');
|
|
}
|
|
putchar('\n');
|
|
}
|
|
|
|
|
|
static void parsepopt(char *arg, unsigned *idx,
|
|
unsigned *r, unsigned *g, unsigned *b)
|
|
{
|
|
char firstarg[21];
|
|
register unsigned i;
|
|
|
|
if(sscanf(arg, "%20[a-zA-Z0-9]%*[,:]%u,%u,%u", firstarg, r, g, b) < 4
|
|
|| strlen(firstarg) == 0)
|
|
errx(2, "too few args in -p i,r,g,b");
|
|
|
|
if(firstarg[0] >= '0' && firstarg[0] <= '9') {
|
|
*idx = strtoul(firstarg, NULL, 10);
|
|
return;
|
|
}
|
|
|
|
for(i = 0; colnames[i].name; i++)
|
|
if(strcasecmp(colnames[i].name, firstarg) == 0) {
|
|
*idx = colnames[i].idx;
|
|
return;
|
|
}
|
|
errx(2, "arg ``%s'' in -p option not recognized", firstarg);
|
|
}
|