mirror of
https://gitlab.com/sortix/sortix.git
synced 2023-02-13 20:55:38 -05:00
381 lines
10 KiB
C++
381 lines
10 KiB
C++
#include <sys/keycodes.h>
|
|
#include <sys/termmode.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <error.h>
|
|
#include <errno.h>
|
|
#include <termios.h>
|
|
#include <readparamstring.h>
|
|
|
|
bool SetCurrentMode(const char* mode)
|
|
{
|
|
FILE* fp = fopen("/dev/video/mode", "w");
|
|
if ( !fp ) { return false; }
|
|
if ( fprintf(fp, "%s\n", mode) < 0 ) { fclose(fp); return false; }
|
|
if ( fclose(fp) ) { return false; }
|
|
return true;
|
|
}
|
|
|
|
char* GetCurrentMode()
|
|
{
|
|
FILE* fp = fopen("/dev/video/mode", "r");
|
|
if ( !fp ) { return NULL; }
|
|
char* mode = NULL;
|
|
size_t n = 0;
|
|
getline(&mode, &n, fp);
|
|
fclose(fp);
|
|
return mode;
|
|
}
|
|
|
|
char** GetAvailableModes(size_t* nummodesptr)
|
|
{
|
|
size_t modeslen = 0;
|
|
char** modes = new char*[modeslen];
|
|
if ( !modes ) { return NULL; }
|
|
size_t nummodes = 0;
|
|
FILE* fp = fopen("/dev/video/modes", "r");
|
|
if ( !fp ) { delete[] modes; return NULL; }
|
|
while ( true )
|
|
{
|
|
char* mode = NULL;
|
|
size_t modesize = 0;
|
|
ssize_t modelen = getline(&mode, &modesize, fp);
|
|
if ( modelen <= 0 ) { break; }
|
|
if ( mode[modelen-1] == '\n' ) { mode[modelen-1] = 0; }
|
|
if ( nummodes == modeslen )
|
|
{
|
|
size_t newmodeslen = modeslen ? 2 * modeslen : 16UL;
|
|
char** newmodes = new char*[newmodeslen];
|
|
if ( !newmodes ) { free(mode); break; }
|
|
memcpy(newmodes, modes, nummodes * sizeof(char*));
|
|
delete[] modes; modes = newmodes;
|
|
modeslen = newmodeslen;
|
|
}
|
|
modes[nummodes++] = mode;
|
|
}
|
|
fclose(fp);
|
|
*nummodesptr = nummodes;
|
|
return modes;
|
|
}
|
|
|
|
void DrawMenu(size_t selection, char** modes, size_t nummodes)
|
|
{
|
|
printf("\e[m\e[H\e[2K"); // Move to (0,0), clear screen.
|
|
printf("Please select one of these video modes or press ESC to abort.\n");
|
|
size_t off = 1; // Above line
|
|
struct winsize ws;
|
|
if ( tcgetwinsize(1, &ws) != 0 )
|
|
ws.ws_row = 25;
|
|
size_t amount = ws.ws_row-off;
|
|
size_t from = (selection / amount) * amount;
|
|
size_t howmanyavailable = nummodes - from;
|
|
size_t howmany = howmanyavailable < amount ? howmanyavailable : amount;
|
|
size_t to = from + howmany - 1;
|
|
for ( size_t i = from; i <= to; i++ )
|
|
{
|
|
size_t screenline = 1 + off + i - from;
|
|
const char* color = i == selection ? "\e[31m" : "\e[m";
|
|
printf("\e[%zuH%s\e[2K%zu\t%s", screenline, color, i, modes[i]);
|
|
}
|
|
printf("\e[m\e[J");
|
|
fflush(stdout);
|
|
}
|
|
|
|
int GetKey(int fd)
|
|
{
|
|
unsigned int oldtermmode;
|
|
gettermmode(fd, &oldtermmode);
|
|
// Read the keyboard input from the user.
|
|
const unsigned termmode = TERMMODE_KBKEY
|
|
| TERMMODE_UNICODE
|
|
| TERMMODE_SIGNAL;
|
|
if ( settermmode(fd, termmode) ) { error(1, errno, "settermmode"); }
|
|
uint32_t codepoint;
|
|
ssize_t numbytes;
|
|
while ( 0 < (numbytes = read(0, &codepoint, sizeof(codepoint))) )
|
|
{
|
|
int kbkey = KBKEY_DECODE(codepoint);
|
|
if ( !kbkey ) { continue; }
|
|
return kbkey;
|
|
}
|
|
settermmode(fd, oldtermmode);
|
|
return 0;
|
|
}
|
|
|
|
int GetKey(FILE* fp) { return GetKey(fileno(fp)); }
|
|
|
|
struct Filter
|
|
{
|
|
bool includeall;
|
|
bool includesupported;
|
|
bool includeunsupported;
|
|
bool includetext;
|
|
bool includegraphics;
|
|
size_t minbpp;
|
|
size_t maxbpp;
|
|
size_t minxres;
|
|
size_t maxxres;
|
|
size_t minyres;
|
|
size_t maxyres;
|
|
size_t minxchars;
|
|
size_t maxxchars;
|
|
size_t minychars;
|
|
size_t maxychars;
|
|
};
|
|
|
|
size_t ParseSizeT(const char* str, size_t def = 0)
|
|
{
|
|
if ( !str || !*str )
|
|
return def;
|
|
char* endptr;
|
|
size_t ret = strtoul(str, &endptr, 10);
|
|
if ( *endptr )
|
|
return def;
|
|
return ret;
|
|
}
|
|
|
|
bool ParseBool(const char* str, bool def = false)
|
|
{
|
|
if ( !str || !*str )
|
|
return def;
|
|
bool isfalse = !strcmp(str, "0") || !strcmp(str, "false");
|
|
return !isfalse;
|
|
}
|
|
|
|
bool PassesFilter(const char* modestr, Filter* filt)
|
|
{
|
|
if ( filt->includeall ) { return true; }
|
|
char* widthstr = NULL;
|
|
char* heightstr = NULL;
|
|
char* bppstr = NULL;
|
|
char* unsupportedstr = NULL;
|
|
char* textstr = NULL;
|
|
if ( !ReadParamString(modestr,
|
|
"width", &widthstr,
|
|
"height", &heightstr,
|
|
"bpp", &bppstr,
|
|
"unsupported", &unsupportedstr,
|
|
"text", &textstr,
|
|
NULL) )
|
|
error(1, errno, "Can't parse video mode: %s", modestr);
|
|
size_t width = ParseSizeT(widthstr, 0); delete[] widthstr;
|
|
size_t height = ParseSizeT(heightstr, 0); delete[] heightstr;
|
|
size_t bpp = ParseSizeT(bppstr, 0); delete[] bppstr;
|
|
bool unsupported = ParseBool(unsupportedstr); delete[] unsupportedstr;
|
|
bool supported = !unsupported;
|
|
bool text = ParseBool(textstr); delete[] textstr;
|
|
bool graphics = !text;
|
|
if ( unsupported && !filt->includeunsupported )
|
|
return false;
|
|
if ( supported && !filt->includesupported )
|
|
return false;
|
|
if ( text && !filt->includetext )
|
|
return false;
|
|
if ( graphics && !filt->includegraphics )
|
|
return false;
|
|
if ( graphics && (bpp < filt->minbpp || filt->maxbpp < bpp) )
|
|
return false;
|
|
if ( graphics && (width < filt->minxres || filt->maxxres < width) )
|
|
return false;
|
|
if ( graphics && (height < filt->minyres || filt->maxyres < height) )
|
|
return false;
|
|
// TODO: Support filtering text modes according to columns/rows.
|
|
return true;
|
|
}
|
|
|
|
void FilterModes(char** modes, size_t* nummodesptr, Filter* filt)
|
|
{
|
|
size_t innum = *nummodesptr;
|
|
size_t outnum = 0;
|
|
for ( size_t i = 0; i < innum; i++ )
|
|
{
|
|
if ( PassesFilter(modes[i], filt) )
|
|
modes[outnum++] = modes[i];
|
|
else
|
|
delete[] modes[i];
|
|
}
|
|
*nummodesptr = outnum;
|
|
}
|
|
|
|
void Usage(FILE* fp, const char* argv0)
|
|
{
|
|
fprintf(fp, "Usage: %s [OPTION ...] [PROGRAM-TO-RUN [ARG ...]]\n", argv0);
|
|
fprintf(fp, "Changes the video mode and optionally runs a program\n");
|
|
fprintf(fp, "\n");
|
|
fprintf(fp, "Options supported by %s:\n", argv0);
|
|
fprintf(fp, " --help, --usage Display this help and exit\n");
|
|
fprintf(fp, " --version Output version information and exit\n");
|
|
fprintf(fp, "\n");
|
|
fprintf(fp, "Options for filtering modes:\n");
|
|
fprintf(fp, " --show-all BOOL\n");
|
|
fprintf(fp, " --show-supported BOOL, --show-unsupported BOOL\n");
|
|
fprintf(fp, " --show-text BOOL\n");
|
|
fprintf(fp, " --show-graphics BOOL\n");
|
|
fprintf(fp, " --bpp BPP, --min-bpp BPP, --max-bpp BPP\n");
|
|
fprintf(fp, " --width NUM, --min-width NUM, --max-width NUM\n");
|
|
fprintf(fp, " --height NUM, --min-height NUM, --max-height NUM\n");
|
|
fprintf(fp, "\n");
|
|
}
|
|
|
|
void Help(FILE* fp, const char* argv0)
|
|
{
|
|
Usage(fp, argv0);
|
|
}
|
|
|
|
void Version(FILE* fp, const char* argv0)
|
|
{
|
|
Usage(fp, argv0);
|
|
}
|
|
|
|
bool SizeTParam(const char* name, const char* option,
|
|
const char* param, size_t* minvar, size_t* maxvar)
|
|
{
|
|
char opt[64]; stpcpy(stpcpy(opt, "--"), name);
|
|
char minopt[64]; stpcpy(stpcpy(minopt, "--min-"), name);
|
|
char maxopt[64]; stpcpy(stpcpy(maxopt, "--max-"), name);
|
|
if ( !strcmp(option, opt) )
|
|
*minvar = *maxvar = ParseSizeT(param);
|
|
else if ( !strcmp(option, minopt) )
|
|
*minvar = ParseBool(param);
|
|
else if ( !strcmp(option, maxopt) )
|
|
*maxvar = ParseBool(param);
|
|
else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool BoolParam(const char* name, const char* option,
|
|
const char* param, bool* var)
|
|
{
|
|
char opt[64]; stpcpy(stpcpy(opt, "--"), name);
|
|
if ( !strcmp(option, opt) )
|
|
*var = ParseBool(param);
|
|
else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
const char* argv0 = argv[0];
|
|
|
|
Filter filt;
|
|
filt.includeall = false;
|
|
filt.includesupported = true;
|
|
filt.includeunsupported = false;
|
|
filt.includetext = true;
|
|
filt.includegraphics = true;
|
|
// TODO: HACK: The kernel log printing requires either text mode or 32-bit
|
|
// graphics. For now, just filter away anything but 32-bit graphics.
|
|
filt.minbpp = 32;
|
|
filt.maxbpp = 32;
|
|
filt.minxres = 0;
|
|
filt.maxxres = SIZE_MAX;
|
|
filt.minyres = 0;
|
|
filt.maxyres = SIZE_MAX;
|
|
filt.minxchars = 0;
|
|
filt.maxxchars = SIZE_MAX;
|
|
filt.minychars = 0;
|
|
filt.maxychars = SIZE_MAX;
|
|
|
|
for ( int i = 1; i < argc; i++ )
|
|
{
|
|
const char* arg = argv[i];
|
|
if ( arg[0] != '-' ) { break; }
|
|
if ( !strcmp(arg, "--") ) { break; }
|
|
if ( !strcmp(arg, "--help") ) { Help(stdout, argv0); exit(0); }
|
|
if ( !strcmp(arg, "--usage") ) { Usage(stdout, argv0); exit(0); }
|
|
if ( !strcmp(arg, "--version") ) { Version(stdout, argv0); exit(0); }
|
|
if ( i == argc-1 )
|
|
{
|
|
fprintf(stderr, "%s: missing parameter to %s\n", argv0, arg);
|
|
Usage(stderr, argv0);
|
|
exit(1);
|
|
}
|
|
const char* p = argv[++i]; argv[i] = NULL;
|
|
bool handled =
|
|
BoolParam("show-all", arg, p, &filt.includeall) ||
|
|
BoolParam("show-supported", arg, p, &filt.includesupported) ||
|
|
BoolParam("show-unsupported", arg, p, &filt.includeunsupported) ||
|
|
BoolParam("show-text", arg, p, &filt.includetext) ||
|
|
BoolParam("show-graphics", arg, p, &filt.includegraphics) ||
|
|
SizeTParam("bpp", arg, p, &filt.minbpp, &filt.maxbpp) ||
|
|
SizeTParam("width", arg, p, &filt.minxres, &filt.maxxres) ||
|
|
SizeTParam("height", arg, p, &filt.minyres, &filt.maxyres) ||
|
|
false;
|
|
if ( !handled )
|
|
{
|
|
fprintf(stderr, "%s: no such option: %s\n", argv0, arg);
|
|
Usage(stderr, argv0);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
char* prevmode = GetCurrentMode();
|
|
if ( !prevmode ) { perror("Unable to detect current mode"); exit(1); }
|
|
#if 1
|
|
size_t nummodes = 0;
|
|
char** modes = GetAvailableModes(&nummodes);
|
|
if ( !modes ) { perror("Unable to detect available video modes"); exit(1); }
|
|
|
|
if ( !nummodes )
|
|
{
|
|
fprintf(stderr, "No video modes are currently available.\n");
|
|
fprintf(stderr, "Try make sure a driver exists and is activated.\n");
|
|
exit(1);
|
|
}
|
|
|
|
FilterModes(modes, &nummodes, &filt);
|
|
if ( !nummodes )
|
|
{
|
|
fprintf(stderr, "\
|
|
No video mode remains after filtering away unwanted modes.\n");
|
|
fprintf(stderr, "\
|
|
Try make sure the desired driver is loaded and is configured correctly.\n");
|
|
exit(1);
|
|
}
|
|
|
|
size_t selection = 0;
|
|
bool decided = false;
|
|
while ( !decided )
|
|
{
|
|
DrawMenu(selection, modes, nummodes);
|
|
switch ( GetKey(stdin) )
|
|
{
|
|
case KBKEY_ESC: printf("\n"); exit(10); break;
|
|
case KBKEY_UP: selection = (nummodes+selection-1) % nummodes; break;
|
|
case KBKEY_DOWN: selection = (selection+1) % nummodes; break;
|
|
case KBKEY_ENTER: decided = true; break;
|
|
}
|
|
}
|
|
|
|
const char* mode = modes[selection];
|
|
if ( !SetCurrentMode(mode) )
|
|
{
|
|
error(1, errno, "Unable to set video mode: %s", mode);
|
|
}
|
|
#endif
|
|
if ( 1 < argc )
|
|
{
|
|
pid_t childpid = fork();
|
|
if ( childpid < 0 ) { perror("fork"); exit(1); }
|
|
if ( childpid )
|
|
{
|
|
int status;
|
|
waitpid(childpid, &status, 0);
|
|
if ( !SetCurrentMode(prevmode) )
|
|
{
|
|
error(1, errno, "Unable to restore video mode: %s", prevmode);
|
|
}
|
|
exit(WEXITSTATUS(status));
|
|
}
|
|
execvp(argv[1], argv + 1);
|
|
perror(argv[1]);
|
|
}
|
|
|
|
return 0;
|
|
}
|