int main(void)
{
PM_HWND hwndConsole;
ulong stateSize;
void *stateBuf;
FILE *f;
/* Allocate a buffer to save console state and save the state */
hwndConsole = PM_openConsole(0,0,0,0,0,true);
stateSize = PM_getConsoleStateSize();
if ((stateBuf = PM_malloc(stateSize)) == NULL) {
PM_closeConsole(hwndConsole);
printf("Unable to allocate console state buffer!\n");
return -1;
}
PM_saveConsoleState(stateBuf,0);
/* Restore the console state on exit */
PM_restoreConsoleState(stateBuf,0);
PM_closeConsole(hwndConsole);
/* Write the saved console state buffer to disk */
if ((f = fopen("/etc/pmsave.dat","wb")) == NULL)
printf("Unable to open /etc/pmsave.dat for writing!\n");
else {
fwrite(&stateSize,1,sizeof(stateSize),f);
fwrite(stateBuf,1,stateSize,f);
fclose(f);
printf("Console state successfully saved to /etc/pmsave.dat\n");
}
PM_free(stateBuf);
return 0;
}
void main(int argc,char *argv[])
{
PM_HWND hwndConsole;
int stateSize;
void *stateBuf;
/* Initialise the console output routines */
hwndConsole = PM_openConsole(0,0,0,0,0,true);
stateSize = PM_getConsoleStateSize();
if ((stateBuf = malloc(stateSize)) == NULL)
PM_fatalError("Out of memory!\n");
PM_saveConsoleState(stateBuf,hwndConsole);
PM_init();
CON_init();
if (argc > 1) {
if (atoi(argv[1]) == 25)
CON_set25LineMode();
else if (atoi(argv[1]) == 43)
CON_set43LineMode();
else if (atoi(argv[1]) == 50)
CON_set50LineMode();
}
do_tests();
do_tests_in_window();
CON_getch();
CON_restoreMode();
PM_restoreConsoleState(stateBuf,hwndConsole);
PM_closeConsole(hwndConsole);
free(stateBuf);
}
/****************************************************************************
REMARKS:
Load the SNAP driver and intialise it.
****************************************************************************/
static GA_devCtx *LoadDriver(
int deviceIndex)
{
GA_devCtx *dc;
/* Save the state of the console */
hwndConsole = PM_openConsole(0,0,640,480,8,true);
if ((stateBuf = malloc(PM_getConsoleStateSize())) == NULL)
PM_fatalError("Out of memory!");
PM_saveConsoleState(stateBuf,hwndConsole);
/* Register our fatal error cleanup handler */
PM_setFatalErrorCleanup(Cleanup);
/* Load the driver */
if ((dc = GA_loadDriver(deviceIndex,false)) == NULL)
PM_fatalError(GA_errorMsg(GA_status()));
init.dwSize = sizeof(init);
if (!GA_queryFunctions(dc,GA_GET_INITFUNCS,&init))
PM_fatalError("Unable to get device driver functions!");
/* Cleanup. We do this here because we know that we will not
* be setting any graphics modes after loading the driver,
* so we can properly restore the console state and make calls
* to non-destructive functions in the driver before we unload
* it.
*/
Cleanup();
return dc;
}
/****************************************************************************
REMARKS:
Does the hard work to create the actual display device context.
****************************************************************************/
static MGLDC * _MGL_createDisplayDC(
int mode,
int virtualX,
int virtualY,
int numBuffers,
ibool stereo,
int refreshRate)
{
MGLDC *dc;
driverent *entry;
modeent *me = &DEV.availableModes[mode];
PM_HWND hwndConsole = (PM_HWND)NULL;
/* Check if the mode is currently available */
__MGL_result = grOK;
if (mode >= DEV.numModes || DEV.availableModes[mode].driver == 0xFF) {
SETERROR(grInvalidMode);
return NULL;
}
_MGL_destroyCurrentMode();
/* Allocate memory for the new DC */
if ((dc = _LST_newNode(sizeof(MGLDC))) == NULL) {
FATALERROR(grNoMem);
return NULL;
}
/* The display device list is currently empty, so create the new
* list and start the specified graphics mode
*/
if ((DEV.dispDCList = _LST_create()) == NULL) {
FATALERROR(grNoMem);
goto Error;
}
/* Open a new fullscreen console for the mode, and save it's state */
DEV.stateBuf = NULL;
if (_MGL_consoleSupport && (GET_CURRENT_DEVICE() == 0)) {
hwndConsole = PM_openConsole((PM_HWND)_MGL_hwndFullScreen,GET_CURRENT_DEVICE(),me->xRes,me->yRes,me->bits,true);
if ((DEV.stateBuf = PM_malloc(PM_getConsoleStateSize())) == NULL) {
FATALERROR(grNoMem);
goto Error;
}
PM_saveConsoleState(DEV.stateBuf,hwndConsole);
}
/* Now intialise the driver */
entry = &DEV.driverTable[me->driver];
if (!_MGL_initDC(dc,entry,me,(MGL_HWND)hwndConsole,virtualX,virtualY,numBuffers,stereo,refreshRate))
goto Error;
/* Set the suspend application callback for the console */
PM_setSuspendAppCallback(_MGL_suspendAppProc);
/* Set up the mouse cursor */
if (_MGL_consoleSupport) {
_MS_setDisplayDC(dc);
MS_setCursor(MGL_DEF_CURSOR);
MS_moveTo(dc->mi.xRes/2,dc->mi.yRes/2);
}
/* Now clear the device page */
MGL_makeCurrentDC(dc);
MGL_clearDevice();
/* And clear the event queue of any extraneous events */
if (_MGL_consoleSupport) {
EVT_flush(EVT_EVERYEVT);
}
/* Add the new DC to the start of the DC chain */
RESET_DEFAULT_CW();
_LST_addToHead(DEV.dispDCList,dc);
return dc;
Error:
if (hwndConsole) {
if (DEV.stateBuf) {
PM_restoreConsoleState(DEV.stateBuf,hwndConsole);
PM_free(DEV.stateBuf);
DEV.stateBuf = NULL;
}
PM_closeConsole(hwndConsole);
}
DEV.fullScreen = false;
if (DEV.dispDCList && DEV.dispDCList->count == 0) {
_LST_destroy(DEV.dispDCList,_LST_freeNode);
DEV.dispDCList = NULL;
}
_LST_freeNode(dc);
return NULL;
}
/****************************************************************************
REMARKS:
Main routine. Expects the x & y resolution of the desired video mode
to be passed on the command line. Will print out a list of available
video modes if no command line is present.
****************************************************************************/
int main(
int argc,
char *argv[])
{
/* Check to see if we are running in a window */
if (PM_runningInAWindow()) {
printf("This program cannot run in a window. Please switch to a fullscreen mode.\n");
return -1;
}
/* Save the state of the console */
hwndConsole = PM_openConsole(0,0,640,480,8,true);
if ((stateBuf = malloc(PM_getConsoleStateSize())) == NULL)
PM_fatalError("Out of memory!");
PM_saveConsoleState(stateBuf,hwndConsole);
/* Register our fatal error cleanup handler */
PM_setFatalErrorCleanup(FatalErrorCleanup);
/* Register the ISV license file if desired */
#ifdef ISV_LICENSE
GA_registerLicense(OemLicense,false);
#endif
/* Load the device driver for this device */
if ((dc = GA_loadDriver(0,false)) == NULL)
PM_fatalError(GA_errorMsg(GA_status()));
init.dwSize = sizeof(init);
if (!GA_queryFunctions(dc,GA_GET_INITFUNCS,&init))
PM_fatalError("Unable to get device driver functions!");
driver.dwSize = sizeof(driver);
if (!GA_queryFunctions(dc,GA_GET_DRIVERFUNCS,&driver))
PM_fatalError("Unable to get device driver functions!");
/* Display available modes for invalid command line */
if (argc != 4) {
/* Restore the console */
PM_restoreConsoleState(stateBuf,hwndConsole);
PM_closeConsole(hwndConsole);
AvailableModes();
GA_unloadDriver(dc);
return 0;
}
/* Get requested resolution, start graphics and draw pattern */
xRes = atoi(argv[1]);
yRes = atoi(argv[2]);
bpp = atoi(argv[3]);
if ((oldMode = InitGraphics(xRes,yRes,bpp)) != -1) {
DrawMoire();
PM_getch();
virtualX = virtualY = bytesPerLine = -1;
init.SetVideoMode(oldMode,&virtualX,&virtualY,&bytesPerLine,&maxMem,0,NULL);
}
/* Restore the console */
ExitSoftwareRasterizer();
PM_restoreConsoleState(stateBuf,hwndConsole);
PM_closeConsole(hwndConsole);
/* Unload the device driver */
GA_unloadDriver(dc);
if (oldMode == -1)
printf("Unable to find specified graphics mode, or error starting mode.\n");
return 0;
}
