GUI::GUI(int & argc,
char **argv,
int XSize,
int YSize) {
fArgc = argc;
fArgv = argv;
::ConInit(-1, -1);
SaveScreen();
::ConSetSize(XSize, YSize);
gui = this;
}
LONG APIENTRY WndProc(
HWND hWnd,
UINT message, // type of message
WPARAM wParam, // additional information
LPARAM lParam) // additional information
{
int newThread; // Thread index to switch to
int i;
ThreadData *ptd;
static HWND hShowing = NULL; // which preview window is being shown
static LONG fntHeight = CONTROLHEIGHT; // height for the edit control
switch (message)
{
case WM_CREATE:
{
HDC hDC;
HBITMAP hBmp;
// Create edit control, button, and label at the bottom of the window
// This will allow the user to input a program to run
SetWindowLong (hWnd, GWL_USERDATA,
(LONG)((CREATESTRUCT *)lParam)->lpCreateParams);
ptd = (ThreadData *)GetWindowLong (hWnd, GWL_USERDATA);
CreateControls (ptd, hWnd);
fntHeight = GetFontHeight (hWnd);
//
// initialize the DC array entry
//
hDC = CreateDC (TEXT("DISPLAY"), NULL, NULL, NULL);
gHDCArray[ptd->index] = CreateCompatibleDC (hDC);
//
// Halftone is the best stretching algorithm
//
SetStretchBltMode (gHDCArray[ptd->index], HALFTONE);
SetBrushOrgEx (gHDCArray[ptd->index], 0, 0, NULL);
//
// Use a bitmap the same size as the desktop preview rectangles
//
hBmp = CreateCompatibleBitmap (hDC, gWidth*2, gHeight*2);
SelectObject (gHDCArray[ptd->index], hBmp);
DeleteDC (hDC);
SaveScreen (ptd->index);
TitleWindow (hWnd);
//
// Register hot keys
//
for (i=0;i<10;i++)
{
RegisterHotKey (hWnd, VK_F1+i, MOD_CONTROL, VK_F1+i);
}
return 0;
}
case WM_SIZE:
{
//
// Put the child controls at the right places
//
#define PADDING 5
RECT rect;
ThreadData *ptd;
if (GetClientRect (hWnd, &rect))
{
ptd = (ThreadData *)GetWindowLong (hWnd, GWL_USERDATA);
MoveWindow (ptd->hWndStatic, 0, rect.bottom - CONTROLHEIGHT,
gStaticWidth, fntHeight + PADDING, TRUE);
MoveWindow (ptd->hWndEdit, gStaticWidth + 5,
rect.bottom - fntHeight - PADDING,
gEditWidth, fntHeight+PADDING, TRUE);
MoveWindow (ptd->hWndBtn, gStaticWidth + gEditWidth + 10,
rect.bottom - fntHeight - PADDING,
gBtnWidth, fntHeight+PADDING, TRUE);
MoveWindow (ptd->hWndNew, gStaticWidth+gEditWidth+gBtnWidth+15,
rect.bottom - fntHeight- PADDING,
gNewWidth, fntHeight+PADDING, TRUE);
}
return 0;
}
case WM_PAINT:
PaintMainWnd (hWnd);
return 0;
case WM_RBUTTONDOWN:
{
//
// Find the rectangle in which the button was pressed
//
POINTS pts;
ThreadData *ptd;
ptd = (ThreadData *)GetWindowLong(hWnd, GWL_USERDATA);
pts = MAKEPOINTS (lParam);
if (pts.y > gHeight)
{
return 1;
}
newThread = pts.x/gWidth;
//
// Get a snapshot of the current desktop
//
SaveScreen (ptd->index);
//
// Switch to the selected desktop
//
if (!gDeskArray[newThread])
{
StartNewDesktop (newThread);
}
if (!SwitchDesktop (gDeskArray[newThread]))
MessageBox (hWnd,
PSZ(IDS_BADDESKTOP),
PSZ(IDS_ERRCAPTION), MB_OK);
return 0;
}
case WM_LBUTTONDOWN:
//
// show the preview window
//
{
POINTS pts;
POINT ptl;
int *index;
pts = MAKEPOINTS (lParam);
if (pts.y > gHeight)
{
return 1;
}
newThread = pts.x/gWidth;
index = GlobalAlloc (GMEM_FIXED, sizeof(int));
if (!index)
{
return 1;
}
*index = newThread;
//
// Want to show the preview window where the button was clicked.
// Map the given points to screen coords.
// ClientToScreen is expecting a POINT structure, not a POINTS
//
ptl.x = (LONG)pts.x;
ptl.y = (LONG)pts.y;
ClientToScreen (hWnd, &ptl);
hShowing = CreateWindow (szPreviewClass, TEXT(""),
WS_POPUP | WS_VISIBLE | WS_BORDER,
ptl.x+3,
ptl.y+3,
gWidth*2,
gHeight*2,
hWnd,
(HMENU)0, ghInst, (LPVOID)index);
return 0;
}
case WM_CHAR:
if (wParam == VK_RETURN)
{
PostMessage (hWnd, WM_COMMAND, (WPARAM)IDC_RUNMEBTN, 0);
}
return 0;
case WM_SYSCHAR:
{
ThreadData *ptd;
ptd = (ThreadData *)GetWindowLong(hWnd, GWL_USERDATA);
switch (wParam)
{
// alt+r == focus on the edit control
case TEXT('r'):
case TEXT('R'):
if (GetKeyState (VK_MENU))
{
SetFocus (ptd->hWndEdit);
}
return 0;
// alt+n = create a new desktop
case TEXT('n'):
case TEXT('N'):
if (GetKeyState (VK_MENU))
{
PostMessage (hWnd, WM_COMMAND, (WPARAM)IDC_NEWDSKBTN, 0);
}
}
return 0;
}
case WM_HOTKEY:
case WM_KEYDOWN:
//
// F1-F9 switches to corresponding desktop
//
if ((wParam >= VK_F1 && wParam <= VK_F10)
&& (wParam - VK_F1 <= (UINT)gMaxIndex))
{
LONG x, y;
x = (wParam - VK_F1) * gWidth + 2;
y = gHeight - 4;
PostMessage (hWnd, WM_RBUTTONDOWN, 0, MAKELPARAM (x, y));
}
return 0;
case WM_SETFOCUS:
case WM_NCLBUTTONUP:
case WM_LBUTTONUP:
//
// destroy the preview window
//
if (hShowing)
{
DestroyWindow (hShowing);
hShowing = NULL;
}
return 0;
case WM_CLOSE:
//
// to be safe, check for a preview window
//
if (hShowing)
{
DestroyWindow (hShowing);
hShowing = NULL;
}
//
// go to the default desktop so the DestroyWindow calls all succeed
//
SwitchDesktop (DEFAULT_DESKTOP);
//
// kill the window on this desktop
// all the windows will be destroyed if this is the default desktop
//
for (i=gMaxIndex;i>=0;i--)
{
DestroyWindow (hWndArray[i]);
}
//
// Unregister the hot keys
//
for (i=0;i<10;i++)
{
UnregisterHotKey (hWnd,VK_F1+i);
}
return 0;
case WM_DESTROY: // message: window being destroyed
PostQuitMessage(0);
return 0;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_RUNMEBTN:
{
RunApp (hWnd);
return 0;
}
case IDC_NEWDSKBTN:
//
// Create a new desktop and resize the windows to show it.
//
{
RECT rect;
int i;
if (gMaxIndex + 1 < MAX_THREADS)
{
gMaxIndex++;
StartNewDesktop (gMaxIndex);
GetWindowRect (hWnd,&rect);
for (i=0;i<gMaxIndex;i++)
{
MoveWindow (hWndArray[i],
rect.left, rect.top,
rect.right + gWidth, rect.bottom-rect.top,
TRUE);
}
}
return 0;
}
default:
return DefWindowProc (hWnd, message, wParam, lParam);
}
}
default: // Passes it on if unprocessed
return (DefWindowProc (hWnd, message, wParam, lParam));
}
}
int GUI::ConContinue(void) {
SaveScreen();
return ::ConContinue();
}
int SerialConfig(void)
{
short key;
short field;
int rval = 0;
char *args[MAXARGS];
int argcount;
char string[MAXARGS*2][12];
int i;
int level;
sinfo = serialinfo; // save copy of modeminfo
SaveScreen();
DrawPup(&cserial);
//
// Set defaults
//
sinfo.skillLevel = 3;
DrawRadios(&sskillg);
sinfo.episode = 1;
#ifndef DOOM2
DrawRadios(&sepig);
#endif
sinfo.deathMatch = 1;
DrawRadios(&sdeathg);
sinfo.comport = comport;
DrawRadios(&scomg);
while(1)
{
SetupMenu(&cserialmenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
//
// Secret WARP code: F5+warp
//
case KEY_F1:
{
level = WarpTime();
if (!level)
continue;
serialinfo = sinfo;
M_SaveDefaults();
RestoreScreen();
argcount = 1;
args[0] = "sersetup.exe ";
if (cdrom)
args[argcount++] = "-cdrom";
args[argcount++] = "-skill";
sprintf(string[argcount],"%d",serialinfo.skillLevel);
args[argcount] = string[argcount];
argcount++;
if (!level)
{
#ifndef DOOM2
args[argcount++] = "-episode";
sprintf(string[argcount],"%d",serialinfo.episode);
args[argcount] = string[argcount];
argcount++;
#endif
}
else
{
args[argcount++] = "-warp";
#ifdef DOOM2
sprintf(string[argcount],"%d",level);
args[argcount] = string[argcount];
#else
sprintf(string[argcount],"%d",level>>8);
args[argcount] = string[argcount];
argcount++;
sprintf(string[argcount],"%d",level&0x0f);
args[argcount] = string[argcount];
#endif
argcount++;
}
if (serialinfo.deathMatch)
args[argcount++] = "-deathmatch";
if (nomonsters)
args[argcount++] = "-nomonsters";
if (respawn)
args[argcount++] = "-respawn";
if (deathmatch2 && serialinfo.deathMatch)
args[argcount++] = "-altdeath";
sprintf(string[argcount],"-com%d",serialinfo.comport);
args[argcount] = string[argcount];
argcount++;
for (i = 1;i < myargc; i++)
args[argcount++] = myargv[i];
args[argcount] = NULL;
textbackground(0);
textcolor(7);
clrscr();
execv("sersetup.exe",args);
//
// ERROR EXECing!
//
printf("Problem EXECing SERSETUP for netplay. Need to be in same directory!");
exit(1);
}
break;
exitandsave:
case KEY_F10:
serialinfo = sinfo;
M_SaveDefaults();
RestoreScreen();
argcount = 1;
args[0] = "sersetup.exe ";
if (cdrom)
args[argcount++] = "-cdrom";
args[argcount++] = "-skill";
sprintf(string[argcount],"%d",serialinfo.skillLevel);
args[argcount] = string[argcount];
argcount++;
if (serialinfo.deathMatch)
args[argcount++] = "-deathmatch";
#ifndef DOOM2
args[argcount++] = "-episode";
sprintf(string[argcount],"%d",serialinfo.episode);
args[argcount] = string[argcount];
argcount++;
#endif
sprintf(string[argcount],"-com%d",serialinfo.comport);
args[argcount] = string[argcount];
argcount++;
for (i = 1;i < myargc; i++)
args[argcount++] = myargv[i];
args[argcount] = NULL;
textbackground(0);
textcolor(7);
clrscr();
execv("sersetup.exe",args);
//
// ERROR EXECing!
//
printf("Problem EXECing SERSETUP for netplay. Need to be in same directory!");
exit(1);
case KEY_ENTER:
case 32:
switch ( field )
{
#ifndef DOOM2
//
// Episode
//
case SER_EPISODE0:
case SER_EPISODE1:
case SER_EPISODE2:
sinfo.episode = field - SER_EPISODE0 + 1;
DrawRadios(&sepig);
break;
#endif
//
// Skill level
//
case SER_SKILL1:
case SER_SKILL2:
case SER_SKILL3:
case SER_SKILL4:
sinfo.skillLevel = field - SER_SKILL1 + 2; break;
//
// Deathmatch
//
case SER_DEATHNO:
case SER_DEATHYES:
sinfo.deathMatch = field - SER_DEATHNO;
break;
//
// COM port
//
case SER_COM1:
case SER_COM2:
case SER_COM3:
case SER_COM4:
comport = sinfo.comport = field - SER_COM1 + 1;
break;
default:
break;
}
DrawRadios(&sskillg);
DrawRadios(&sdeathg);
DrawRadios(&scomg);
break;
}
}
func_exit:
RestoreScreen();
return ( rval );
}
int RestoreSerial(void)
{
short field;
short key;
int rval = 0;
char *args[MAXARGS];
int argcount;
char string[MAXARGS*2][16];
int i;
int numplayers[6];
int saveslot;
int handle;
char name[32];
char p1,p2,p3,p4;
sinfo = serialinfo; // save copy of netinfo
SaveScreen();
DrawPup(&sersave);
saveslot = -1;
memset(savenames,0,6*24);
//
// Read in savegame strings
//
textbackground(1);
textcolor(15);
for (i = 0;i < 6;i++)
{
sprintf(name,SAVENAME,i);
handle = open (name, O_BINARY | O_RDONLY);
if (handle == -1)
continue;
read(handle,savenames[i],24);
lseek(handle,27+16,SEEK_SET);
read(handle,&p1,1);
read(handle,&p2,1);
read(handle,&p3,1);
read(handle,&p4,1);
numplayers[i] = p1+p2+p3+p4;
close(handle);
Clear(&sersaveitems[i]);
Pos(&sersaveitems[i]);
cprintf("%s",savenames[i]);
}
//
// Set defaults
//
sinfo.comport = comport;
DrawRadios(&serscomg);
sinfo.deathMatch = 0;
DrawRadios(&sersdeathg);
gotoxy(1,25);
while(1)
{
SetupMenu(&sersavemenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
exitandsave:
case KEY_F10:
if (saveslot < 0)
{
ErrorWindow(&netserr);
break;
}
serialinfo = sinfo;
M_SaveDefaults();
RestoreScreen();
argcount = 1;
args[0] = "sersetup.exe ";
if (cdrom)
args[argcount++] = "-cdrom";
args[argcount++] = "-nodes";
sprintf(string[argcount],"%d",numplayers[saveslot]);
args[argcount] = string[argcount];
argcount++;
if (modeminfo.deathMatch)
args[argcount++] = "-deathmatch";
sprintf(string[argcount],"-com%d",serialinfo.comport);
args[argcount] = string[argcount];
argcount++;
args[argcount++] = "-loadgame";
sprintf(string[argcount],"%d",saveslot);
args[argcount] = string[argcount];
argcount++;
for (i = 1;i < myargc; i++)
args[argcount++] = myargv[i];
args[argcount] = NULL;
textbackground(0);
textcolor(7);
clrscr();
execv("sersetup.exe",args);
//
// ERROR EXECing!
//
printf("Problem EXECing SERSETUP for netplay. Need to be in same directory!");
exit(0);
case KEY_ENTER:
switch ( field )
{
case SERS_COM1:
case SERS_COM2:
case SERS_COM3:
case SERS_COM4:
sinfo.comport = field - SERS_COM1 + 1;
DrawRadios(&serscomg);
break;
case SERS_0:
case SERS_1:
case SERS_2:
case SERS_3:
case SERS_4:
case SERS_5:
if (!savenames[field - SERS_0][0])
{
Sound(1000,12);
break;
}
saveslot = field - SERS_0;
DrawRadios(&serslotsg);
break;
//
// Deathmatch
//
case SERS_DEATHNO:
case SERS_DEATHYES:
sinfo.deathMatch = field - SERS_DEATHNO;
DrawRadios(&sersdeathg);
default:
break;
}
break;
}
}
func_exit:
RestoreScreen();
return ( rval );
}
int ChooseController (void)
{
short key;
short field;
int rval = 0;
SaveScreen();
DrawPup(&control);
// DEFAULT FIELD ========================================
if (newc.control == C_MOUSE)
field = CON_MOUSE;
else
if (newc.control == C_JOYSTICK)
field = CON_JOY;
else
field = CON_KEY;
controlmenu.startitem = field;
while(1)
{
SetupMenu(&controlmenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
case KEY_ENTER:
case KEY_F10:
switch ( field )
{
case CON_KEY:
newc.control = C_KEY;
usemouse = 0;
usejoystick = 0;
goto func_exit;
case CON_MOUSE:
newc.control = C_MOUSE;
usemouse = 1;
usejoystick = 0;
goto func_exit;
case CON_JOY:
newc.control = C_JOYSTICK;
usemouse = 0;
usejoystick = 1;
goto func_exit;
default:
break;
}
break;
}
}
func_exit:
RestoreScreen();
DrawCurrentConfig();
return ( rval );
}
int ChooseNumDig (void)
{
short key;
short field;
int rval = 0;
SaveScreen();
DrawPup(&numdig);
// DEFAULT FIELD ========================================
switch ( newc.numdig )
{
default:
field = DIG_4;
break;
case 1:
field = DIG_1;
break;
case 2:
field = DIG_2;
break;
case 3:
field = DIG_3;
break;
case 4:
field = DIG_4;
break;
case 5:
field = DIG_5;
break;
case 6:
field = DIG_6;
break;
case 7:
field = DIG_7;
break;
case 8:
field = DIG_8;
break;
}
numdigmenu.startitem = field;
while(1)
{
SetupMenu(&numdigmenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
case KEY_ENTER:
case KEY_F10:
switch ( field )
{
case DIG_1:
newc.numdig = 1;
goto func_exit;
case DIG_2:
newc.numdig = 2;
goto func_exit;
case DIG_3:
newc.numdig = 3;
goto func_exit;
case DIG_4:
newc.numdig = 4;
goto func_exit;
case DIG_5:
newc.numdig = 5;
goto func_exit;
case DIG_6:
newc.numdig = 6;
goto func_exit;
case DIG_7:
newc.numdig = 7;
goto func_exit;
case DIG_8:
newc.numdig = 8;
goto func_exit;
default:
break;
}
break;
}
}
func_exit:
RestoreScreen();
return ( rval );
}
int ChooseFxCard (void)
{
short field;
short key;
int rval = 0;
switch ( newc.d.card )
{
default:
case M_NONE:
field = DCARD_NONE;
break;
#ifndef HERETIC
case M_PC:
field = DCARD_PC;
break;
#endif
case M_GUS:
field = DCARD_GUS;
break;
case M_SB:
field = DCARD_SB;
break;
case M_PAS:
field = DCARD_PAS;
break;
case M_WAVE:
field = DCARD_SB;
break;
}
SaveScreen();
DrawPup(&idcard);
idcardmenu.startitem = field;
while(1)
{
SetupMenu(&idcardmenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
case KEY_ENTER:
case KEY_F10:
switch ( field )
{
case DCARD_PAS:
newc.d.card = M_PAS;
goto func_exit;
case DCARD_SB:
newc.d.card = M_SB;
goto func_exit;
case DCARD_GUS:
newc.d.card = M_GUS;
newc.d.midiport = -1;
goto func_exit;
#ifndef HERETIC
case DCARD_PC:
newc.d.card = M_PC;
newc.d.port = -1;
newc.d.midiport = -1;
newc.d.irq = -1;
newc.d.dma = -1;
goto func_exit;
#endif
case DCARD_NONE:
newc.d.card = M_NONE;
newc.d.port = -1;
newc.d.midiport = -1;
newc.d.irq = -1;
newc.d.dma = -1;
goto func_exit;
default:
break;
}
break;
}
}
func_exit:
RestoreScreen();
return ( rval );
}
int ChooseSbIrq (DMXCARD * card)
{
short field;
short key;
int rval = 0;
if ( card->irq > 8 )
ErrorWindow(&irqerr);
switch ( card->irq )
{
case 2:
field = SB_IRQ_2;
break;
default:
case 5:
field = SB_IRQ_5;
break;
case 7:
field = SB_IRQ_7;
break;
}
SaveScreen();
DrawPup(&sbirq);
sbirqmenu.startitem = field;
while(1)
{
SetupMenu(&sbirqmenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
case KEY_ENTER:
case KEY_F10:
switch ( field )
{
case SB_IRQ_2:
card->irq = 2;
goto func_exit;
case SB_IRQ_5:
card->irq = 5;
goto func_exit;
case SB_IRQ_7:
card->irq = 7;
goto func_exit;
default:
break;
}
break;
}
}
func_exit:
RestoreScreen();
return ( rval );
}
int ChooseSbDma (DMXCARD * card)
{
short key;
short field;
int rval = 0;
switch ( card->dma )
{
case 0:
field = SB_DMA_0;
break;
default:
case 1:
field = SB_DMA_1;
break;
case 3:
field = SB_DMA_3;
break;
case 5:
field = SB_DMA_5;
break;
case 6:
field = SB_DMA_6;
break;
case 7:
field = SB_DMA_7;
break;
}
SaveScreen();
DrawPup(&sbdma);
sbdmamenu.startitem = field;
while(1)
{
SetupMenu(&sbdmamenu);
field = GetMenuInput();
key = menukey;
switch ( key )
{
case KEY_ESC:
rval = -1;
goto func_exit;
case KEY_ENTER:
case KEY_F10:
switch ( field )
{
case SB_DMA_0:
card->dma = 0;
goto func_exit;
case SB_DMA_1:
card->dma = 1;
goto func_exit;
case SB_DMA_3:
card->dma = 3;
goto func_exit;
case SB_DMA_5:
card->dma = 5;
goto func_exit;
case SB_DMA_6:
card->dma = 6;
goto func_exit;
case SB_DMA_7:
card->dma = 7;
goto func_exit;
default:
break;
}
break;
}
}
func_exit:
RestoreScreen();
return ( rval );
}
HANDLE CStartupInfo::SaveScreen()
{
return SaveScreen(0, 0, -1, -1);
}
unsigned WarpTime(void)
{
int e;
int l;
short key;
short field;
int exit;
SaveScreen();
DrawPup(&cwarp);
SetMark(&cwarpitems[W_RESPAWN],respawn);
SetMark(&cwarpitems[W_NOMON],nomonsters);
#ifndef HERETIC
SetMark(&cwarpitems[W_DM2],deathmatch2);
#endif
exit = 0;
while(1)
{
SetupMenu(&cwarpmenu);
field = GetMenuInput();
key = menukey;
switch(key)
{
case KEY_ESC:
RestoreScreen();
return 0;
case KEY_F10:
case KEY_ENTER:
switch(field)
{
case E1M1: e=1;l=1; exit=1; break;
case E1M2: e=1;l=2; exit=1; break;
case E1M3: e=1;l=3; exit=1; break;
case E1M4: e=1;l=4; exit=1; break;
case E1M5: e=1;l=5; exit=1; break;
case E1M6: e=1;l=6; exit=1; break;
case E1M7: e=1;l=7; exit=1; break;
case E1M8: e=1;l=8; exit=1; break;
case E1M9: e=1;l=9; exit=1; break;
#ifdef DOOM2
case E1M10: e=1;l=10; exit=1; break;
#endif
case E2M1: e=2;l=1; exit=1; break;
case E2M2: e=2;l=2; exit=1; break;
case E2M3: e=2;l=3; exit=1; break;
case E2M4: e=2;l=4; exit=1; break;
case E2M5: e=2;l=5; exit=1; break;
case E2M6: e=2;l=6; exit=1; break;
case E2M7: e=2;l=7; exit=1; break;
case E2M8: e=2;l=8; exit=1; break;
case E2M9: e=2;l=9; exit=1; break;
#ifdef DOOM2
case E2M10: e=2;l=10; exit=1; break;
#endif
case E3M1: e=3;l=1; exit=1; break;
case E3M2: e=3;l=2; exit=1; break;
case E3M3: e=3;l=3; exit=1; break;
case E3M4: e=3;l=4; exit=1; break;
case E3M5: e=3;l=5; exit=1; break;
case E3M6: e=3;l=6; exit=1; break;
case E3M7: e=3;l=7; exit=1; break;
case E3M8: e=3;l=8; exit=1; break;
case E3M9: e=3;l=9; exit=1; break;
#ifdef DOOM2
case E3M10: e=3;l=10; exit=1; break;
#endif
case W_RESPAWN:
respawn ^= 1;
SetMark(&cwarpitems[W_RESPAWN],respawn);
break;
case W_NOMON:
nomonsters ^= 1;
SetMark(&cwarpitems[W_NOMON],nomonsters);
break;
#ifndef HERETIC
case W_DM2:
deathmatch2 ^= 1;
SetMark(&cwarpitems[W_DM2],deathmatch2);
break;
#endif
}
if (exit)
{
RestoreScreen();
#ifdef DOOM2
return ((e-1)*10+l);
#else
return (e<<8)+l;
#endif
}
}
}
}
bool ViewerIBA::OnKeyDown(int key) {
#ifdef __linux__
if (key == VW_KEY_CTRL_KEY_VALUE) {
m_ctrlDown = true;
return true;
}
if (m_ctrlDown) {
key = key - 'a' + 1;
}
#endif
if (Viewer::OnKeyDown(key)) {
return true;
}
//#ifdef CFG_DEBUG
#if 0
//#if 1
UT::Print("%d\n", key);
#endif
//#ifdef CFG_DEBUG
#if 0
if (key == '+' || key == '-') {
Camera &C = m_LBA->m_CsLF[m_iLFActive];
if (key == '+') {
C.m_p.y() += 0.1f;
} else {
C.m_p.y() -= 0.1f;
}
C.m_T.SetPosition(C.m_p);
return true;
}
#endif
#ifdef CFG_STEREO
if (key == '1' || key == '2') {
ActivateCamera(key == '2');
return true;
}
#endif
const int nKFs = GetKeyFrames();
const bool activeKF = m_iFrmActive < nKFs;
switch (key) {
case VW_KEY_XD_DRAW_VIEW_TYPE:
if (m_keyDrawViewType == DRAW_VIEW_PROFILE) {
m_keyDrawViewType = m_keyDrawViewTypeBkp;
} else {
m_keyDrawViewType.Press();
}
return true;
case VW_KEY_XD_PAUSE: m_keyPause.Press(); return true;
case VW_KEY_XD_STEP: m_keyStep.Press(); return true;
case VW_KEY_XD_SAVE:
if (m_fileNameSave == "") {
m_fileNameSave = UT::Input<std::string>("save_file");
}
m_iFrmSave = GetLocalFrame(m_iLF)->m_T.m_iFrm;
m_keyStep.Press();
//m_handler.Quit();
return true;
case VW_KEY_XD_SCREEN:
if (m_fileNameScreen == "") {
m_fileNameScreen = UT::Input<std::string>("screen_file");
}
if (m_fileNameScreen != "" && UT::FileNameExtractSuffix<int>(m_fileNameScreen) == -1) {
bool resize = m_pWnd->size().x != m_K.m_K.w() || m_pWnd->size().y != m_K.m_K.h();
if (resize) {
const char inp = UT::Input<char>("resize (y/n)");
if (inp != 'y' && inp != 'Y') {
resize = false;
}
}
SaveScreen(UT::FileNameAppendSuffix(m_fileNameScreen), resize);
}
return true;
//case VW_KEY_XD_ACTIVATE_NEXT_FRAME: ActivateFrame(m_iFrmActive + 1); return true;
//case VW_KEY_XD_ACTIVATE_LAST_FRAME: ActivateFrame(m_iFrmActive - 1); return true;
case VW_KEY_XD_ACTIVATE_NEXT_FRAME:
case VW_KEY_XD_ACTIVATE_LAST_FRAME: {
const bool next = key == VW_KEY_XD_ACTIVATE_NEXT_FRAME;
int iFrm = next ? m_iFrmActive + 1 : m_iFrmActive - 1;
if (m_iFtrActive.Valid()) {
const int nLFs = GetLocalFrames(), nFrms = nKFs + nLFs;
const int iKF = m_iFtrActive.m_ix.m_iKF, ix = m_iFtrActive.m_ix.m_ix;
while (iFrm >= 0 && iFrm < nFrms && iFrm != iKF) {
const FRM::Frame &F = *(iFrm < nKFs ? GetKeyFrame(iFrm) :
GetLocalFrame((iFrm - nKFs + m_iLF + 1) % nLFs));
const int iz = F.SearchFeatureMeasurement(iKF, ix);
if (iz != -1
#ifdef CFG_STEREO
&& (!m_rightActive && F.m_zs[iz].m_z.Valid() || m_rightActive && F.m_zs[iz].m_zr.Valid())
#endif
) {
break;
}
iFrm = next ? iFrm + 1 : iFrm - 1;
}
}
ActivateFrame(iFrm);
return true;
}
case VW_KEY_XD_ACTIVATE_KEY_FRAME:
if (m_iFtrActive.m_ix.Valid()) {
ActivateFrame(m_iFtrActive.m_ix.m_iKF);
} else {
ActivateFrame(m_iKFActive);
}
return true;
case VW_KEY_XD_ACTIVATE_LOCAL_FRAME:
if (m_iFtrActive.m_iz.Valid() && m_iFtrActive.m_iz.m_iLF != -1) {
ActivateLocalFrame(m_iFtrActive.m_iz.m_iLF);
} else if (activeKF) {
ActivateLocalFrame(m_iLFActive);
} else {
ActivateLocalFrame(m_iLFActiveLast);
}
return true;
case VW_KEY_XD_ACTIVATE_CURRENT_FRAME:
ActivateLocalFrame(m_iLF);
return true;
case VW_KEY_XD_DRAW_CAMERA_TYPE_NEXT:
case VW_KEY_XD_DRAW_CAMERA_TYPE_LAST:
if (activeKF) {
m_keyDrawCamTypeKF.Press(key == VW_KEY_XD_DRAW_CAMERA_TYPE_NEXT, false);
switch (m_keyDrawCamTypeKF) {
case DRAW_CAM_KF_LBA:
m_keyDrawCamTypeLF = DRAW_CAM_LF_LBA;
m_keyDrawDepType = DRAW_DEP_LBA;
break;
case DRAW_CAM_KF_GBA:
m_keyDrawDepType = DRAW_DEP_GBA;
break;
#ifdef CFG_GROUND_TRUTH
case DRAW_CAM_KF_GT:
m_keyDrawCamTypeLF = DRAW_CAM_LF_GT;
if (!m_solver->m_internal->m_DsGT.empty()) {
m_keyDrawDepType = DRAW_DEP_GT;
}
break;
#endif
}
} else {
m_keyDrawCamTypeLF.Press(key == VW_KEY_XD_DRAW_CAMERA_TYPE_NEXT, false);
switch (m_keyDrawCamTypeLF) {
case DRAW_CAM_LF_LBA:
m_keyDrawCamTypeKF = DRAW_CAM_KF_LBA;
m_keyDrawDepType = DRAW_DEP_LBA;
break;
#ifdef CFG_GROUND_TRUTH
case DRAW_CAM_LF_GT:
m_keyDrawCamTypeKF = DRAW_CAM_KF_GT;
if (!m_solver->m_internal->m_DsGT.empty()) {
m_keyDrawDepType = DRAW_DEP_GT;
}
break;
#endif
}
}
ActivateFrame(m_iFrmActive);
return true;
#ifdef CFG_GROUND_TRUTH
case VW_KEY_XD_DRAW_CAMERA_TYPE_GROUND_TRUTH:
if (activeKF && m_keyDrawCamTypeKF == DRAW_CAM_KF_GT) {
m_keyDrawCamTypeKF.Set(DRAW_CAM_KF_GBA);
m_keyDrawDepType = DRAW_DEP_GBA;
} else if (!activeKF && m_keyDrawCamTypeLF == DRAW_CAM_LF_GT) {
m_keyDrawCamTypeKF.Set(DRAW_CAM_KF_LBA);
m_keyDrawCamTypeLF = DRAW_CAM_LF_LBA;
m_keyDrawDepType = DRAW_DEP_LBA;
} else if (activeKF && GetCameraKF(m_iKFActive, DRAW_CAM_KF_GT).Valid() ||
!activeKF && GetCameraLF(m_iLFActive, DRAW_CAM_LF_GT).Valid()) {
m_keyDrawCamTypeKF.Set(DRAW_CAM_KF_GT);
m_keyDrawCamTypeLF = DRAW_CAM_LF_GT;
if (!m_solver->m_internal->m_DsGT.empty()) {
m_keyDrawDepType = DRAW_DEP_GT;
}
}
ActivateFrame(m_iFrmActive);
return true;
#endif
case VW_KEY_XD_DRAW_DEPTH_TYPE_NEXT:
case VW_KEY_XD_DRAW_DEPTH_TYPE_LAST:
m_keyDrawDepType.Press(key == VW_KEY_XD_DRAW_DEPTH_TYPE_NEXT, false);
return true;
case VW_KEY_XD_DRAW_STRING: m_keyDrawString.Press(); return true;
case VW_KEY_XD_DRAW_TIME_LINE: m_keyDrawTlnType.Press(); return true;
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_1:
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_1:
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_2:
case VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_2:
if (m_keyDrawTlnType == DRAW_TLN_FEATURE_MATCH) {
m_keyDrawTlnMaxFtrMatches.Press(key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_1 ||
key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_2);
} else if (key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_1 ||
key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_DECREASE_1) {
m_keyDrawTlnPriorVarPos.Press(key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_1);
} else {
m_keyDrawTlnPriorVarRot.Press(key == VW_KEY_XD_DRAW_TIME_LINE_BRIGHTNESS_INCREASE_2);
}
return true;
}
if (m_keyDrawViewType == DRAW_VIEW_2D || m_keyDrawViewType == DRAW_VIEW_3D) {
switch (key) {
case VW_KEY_XD_DRAW_AXIS:
m_keyDrawAxis.Press();
return true;
case VW_KEY_XD_DRAW_AXIS_LENGTH_INCREASE:
case VW_KEY_XD_DRAW_AXIS_LENGTH_DECREASE:
if (m_keyDrawAxis != DRAW_AXIS_NONE) {
m_keyDrawAxisLen.Press(key == VW_KEY_XD_DRAW_AXIS_LENGTH_INCREASE);
m_frustrum.SetAxisLength(m_keyDrawAxisLen);
m_frustrumActive.SetAxisLength(m_keyDrawAxisLen);
return true;
}
break;
case VW_KEY_XD_DRAW_DEPTH_PLANE:
m_keyDrawDepPlane.Press();
return true;
case VW_KEY_XD_DRAW_DEPTH_VARIANCE_INCREASE:
case VW_KEY_XD_DRAW_DEPTH_VARIANCE_DECREASE:
m_keyDrawDepVar.Press(key == VW_KEY_XD_DRAW_DEPTH_VARIANCE_INCREASE);
return true;
case VW_KEY_XD_DRAW_COVARIANCE_PROBABILITY_INCREASE:
case VW_KEY_XD_DRAW_COVARIANCE_PROBABILITY_DECREASE:
if (m_keyDrawTlnType != DRAW_TLN_NONE ||
(m_keyDrawViewType == DRAW_VIEW_2D && (m_keyDrawErrType2D == DRAW_ERR_ALL ||
m_keyDrawErrType2D == DRAW_ERR_COVARIANCE)) ||
(m_keyDrawViewType == DRAW_VIEW_3D && (m_keyDrawErrType3D == DRAW_ERR_ALL ||
m_keyDrawErrType3D == DRAW_ERR_COVARIANCE))) {
m_keyDrawCovProb.Press(key == VW_KEY_XD_DRAW_COVARIANCE_PROBABILITY_INCREASE);
return true;
}
break;
case VW_KEY_XD_DRAW_COVARIANCE_SCALE_INCREASE:
case VW_KEY_XD_DRAW_COVARIANCE_SCALE_DECREASE:
if (m_keyDrawTlnType != DRAW_TLN_NONE ||
(m_keyDrawViewType == DRAW_VIEW_2D && (m_keyDrawErrType2D == DRAW_ERR_ALL ||
m_keyDrawErrType2D == DRAW_ERR_COVARIANCE)
|| m_keyDrawViewType == DRAW_VIEW_3D && (m_keyDrawErrType3D == DRAW_ERR_ALL ||
m_keyDrawErrType3D == DRAW_ERR_COVARIANCE))) {
m_keyDrawCovScale.Press(key == VW_KEY_XD_DRAW_COVARIANCE_SCALE_INCREASE);
return true;
}
break;
case VW_KEY_XD_INPUT_ACTIVE_FEATURE: {
const int iFrm = UT::Input<int>(" Frame");
const std::vector<KeyFrame>::const_iterator iKF = std::lower_bound(m_GBA->m_KFs.begin(),
m_GBA->m_KFs.end(), iFrm);
if (iKF != m_GBA->m_KFs.end() && *iKF == iFrm) {
const int ix = UT::Input<int>("Source");
if (ix < 0 || ix >= static_cast<int>(iKF->m_xs.size())) {
return false;
}
const int _iKF = static_cast<int>(iKF - m_GBA->m_KFs.begin());
const FRM::Frame &F = *(activeKF ? GetKeyFrame(m_iKFActive) : GetLocalFrame(m_iLFActive));
const int iz = F.SearchFeatureMeasurement(_iKF, ix);
ActivateFeature(FeatureIndex::Source(_iKF, ix), iz);
}
return false;
}
case VW_KEY_PROFILE_ACTIVATE:
if (m_keyDrawViewType != DRAW_VIEW_PROFILE) {
m_keyDrawViewTypeBkp = m_keyDrawViewType;
m_keyDrawViewType = DRAW_VIEW_PROFILE;
}
return true;
}
} else if (m_keyDrawViewType == DRAW_VIEW_PROFILE) {
switch (key) {
case VW_KEY_PROFILE_ACTIVATE:
m_keyDrawViewType = m_keyDrawViewTypeBkp;
return true;
case VM_KEY_PROFILE_LEVEL_1_NEXT:
case VM_KEY_PROFILE_LEVEL_1_LAST: {
const int types[] = {DRAW_PRF_ACCELERATION, DRAW_PRF_IMU_DELTA_ROTATION_STATE,
DRAW_PRF_CAMERA_PRIOR_ROTATION_STATE, DRAW_PRF_REPROJECTION_ERROR,
DRAW_PRF_STATE_ROTATION_ABSOLUTE,
DRAW_PRF_TYPES};
const int N = sizeof(types) / sizeof(int);
DrawProfileTypeStep(types, N, key == VM_KEY_PROFILE_LEVEL_1_NEXT);
return true; }
case VM_KEY_PROFILE_LEVEL_2_NEXT:
case VM_KEY_PROFILE_LEVEL_2_LAST: {
const int types[] = {DRAW_PRF_ACCELERATION, DRAW_PRF_GYROSCOPE,
DRAW_PRF_IMU_DELTA_ROTATION_STATE,
DRAW_PRF_IMU_DELTA_POSITION_STATE,
DRAW_PRF_IMU_DELTA_VELOCITY_STATE,
DRAW_PRF_IMU_DELTA_BIAS_ACCELERATION_STATE,
DRAW_PRF_IMU_DELTA_BIAS_GYROSCOPE_STATE,
DRAW_PRF_CAMERA_PRIOR_ROTATION_STATE,
DRAW_PRF_CAMERA_PRIOR_POSITION_STATE,
DRAW_PRF_CAMERA_PRIOR_VELOCITY_STATE,
DRAW_PRF_CAMERA_PRIOR_BIAS_ACCELERATION_STATE,
DRAW_PRF_CAMERA_PRIOR_BIAS_GYROSCOPE_STATE,
DRAW_PRF_REPROJECTION_ERROR,
DRAW_PRF_STATE_ROTATION_ABSOLUTE,
DRAW_PRF_STATE_POSITION_ABSOLUTE,
DRAW_PRF_STATE_VELOCITY,
DRAW_PRF_STATE_BIAS_ACCELERATION,
DRAW_PRF_STATE_BIAS_GYROSCOPE,
DRAW_PRF_TYPES};
const int N = sizeof(types) / sizeof(int);
DrawProfileTypeStep(types, N, key == VM_KEY_PROFILE_LEVEL_2_NEXT);
return true; }
case VM_KEY_PROFILE_LEVEL_3_NEXT:
case VM_KEY_PROFILE_LEVEL_3_LAST: {
const int typeBkp = m_keyDrawPrfType;
while (m_keyDrawPrfType.Press(key == VM_KEY_PROFILE_LEVEL_3_NEXT, false) &&
!DrawProfileTypeValid()) {}
if (!DrawProfileTypeValid()) {
m_keyDrawPrfType = typeBkp;
}
return true; }
}
}
if (m_keyDrawViewType == DRAW_VIEW_2D) {
switch (key) {
case VW_KEY_2D_DRAW_FEATURE_TYPE: m_keyDrawFtrType.Press(); return true;
case VW_KEY_2D_DRAW_PROJECTION_TYPE: m_keyDrawPrjType.Press(); return true;
case VW_KEY_2D_DRAW_ERROR_TYPE: m_keyDrawErrType2D.Press(); return true;
}
} else if (m_keyDrawViewType == DRAW_VIEW_3D) {
switch (key) {
case VW_KEY_3D_DRAW_MOTION_TYPE:
if (activeKF) {
m_keyDrawMotTypeKF.Press();
} else {
m_keyDrawMotTypeLF.Press();
}
return true;
case VW_KEY_3D_DRAW_STRUCTURE_TYPE:
m_keyDrawStrType.Press();
return true;
case VW_KEY_3D_DRAW_DEPTH_COMPARE_TYPE:
if (m_keyDrawErrType3D == DRAW_ERR_ALL || m_keyDrawErrType3D == DRAW_ERR_MEAN) {
m_keyDrawDepTypeCMP.Press();
//while(m_keyDrawDepTypeCMP == m_keyDrawDepType)
// m_keyDrawDepTypeCMP.Press();
}
return true;
case VW_KEY_3D_DRAW_CAMERA_SIZE_INCREASE:
case VW_KEY_3D_DRAW_CAMERA_SIZE_DECREASE:
m_keyDrawCamSize.Press(key == VW_KEY_3D_DRAW_CAMERA_SIZE_INCREASE);
m_frustrum.SetSize(m_keyDrawCamSize);
m_frustrumActive.SetSize(m_keyDrawCamSize * VW_CAMERA_SIZE_ACTIVE_RATIO);
return true;
case VW_KEY_3D_DRAW_CAMERA_VELOCITY: m_keyDrawCamVelocity.Press(); break;
case VW_KEY_3D_DRAW_CAMERA_TEXTURE: m_keyDrawCamTex.Press(); break;
#ifdef CFG_GROUND_TRUTH
case VW_KEY_3D_DRAW_CAMERA_GROUND_TRUTH: m_keyDrawCamGT.Press(); break;
#endif
case VW_KEY_3D_DRAW_ERROR_TYPE:
m_keyDrawErrType3D.Press();
return true;
case VW_KEY_3D_DRAW_BACKGROUND_COLOR:
m_keyDrawBgClr.Press();
Update3DBackgroundColor();
return true;
case VW_KEY_3D_RESET_VIEW_POINT_ACTIVE:
case VW_KEY_3D_RESET_VIEW_POINT_VIRTUAL:
Reset3DViewPoint(key == VW_KEY_3D_RESET_VIEW_POINT_ACTIVE);
return true;
}
}
return false;
}
