static void
onNext(void * /* dummy */)
{
/* Back to previous screen */
if (CalState == 4 && NextMenuHandle != NULL)
GfuiScreenActivate(NextMenuHandle);
else
GfuiScreenActivate(PrevMenuHandle);
}
static void
QuitHookActivate(void * /* dummy */)
{
if (StopScrHandle) {
GfuiScreenActivate(TorcsExitMenuInit(StopScrHandle));
}
}
// Save the choosen values in the corresponding parameter file.
static void saveSoundOption(void *)
{
// Force current edit to loose focus (if one has it) and update associated variable.
GfuiUnSelectCurrent();
char buf[1024];
sprintf(buf, "%s%s", GfLocalDir(), SND_PARAM_FILE);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfParmSetStr(paramHandle, SND_SCT_SOUND, SND_ATT_SOUND_STATE, soundOptionList[curOption]);
GfParmSetNum(paramHandle, SND_SCT_SOUND, SND_ATT_SOUND_VOLUME, "%", VolumeValue);
GfParmSetStr(paramHandle, SND_SCT_MUSIC, SND_ATT_MUSIC_STATE, musicStateList[curMusicState]);
GfParmSetNum(paramHandle, SND_SCT_MUSIC, SND_ATT_MUSIC_VOLUME, "%", MusicVolumeValue);
GfParmWriteFile(NULL, paramHandle, "sound");
GfParmReleaseHandle(paramHandle);
// Shutdown the user interface.
LegacyMenu::self().shutdown();
// Restart the game.
GfuiApp().restart();
// Return to previous screen.
GfuiScreenActivate(prevHandle);
}
static void
RestartRaceHookActivate(void * /* dummy */)
{
ReRaceCleanup();
ReInfo->_reState = RE_STATE_PRE_RACE;
GfuiScreenActivate(ReInfo->_reGameScreen);
}
void PCreateSetLengthMenu(void* ts)
{
handle = GfuiScreenCreate();
fManager = PFileManager::Get();
// Create Title
GfuiTitleCreate(handle, "Set Length", std::string("Set Length").length());
// Set up background image
GfuiScreenAddBgImg(handle, "data/img/splash-filesel.png");
// Create Edit Box
GfuiLabelCreate(handle, "Track Length (km):", GFUI_FONT_MEDIUM, 310, 260, GFUI_ALIGN_HC_VC, std::string("Track Length (km):").length());
editBoxID = GfuiEditboxCreate(handle, "1000", GFUI_FONT_MEDIUM, 265, 240, 100, 20, nullptr, nullptr, PUpdateEditBox);
// Create error label
errLabelID = GfuiLabelCreate(handle, " ", GFUI_FONT_MEDIUM, 30, 0, GFUI_ALIGN_HL_VB, 256);
float col[4] = { 1.f, 0.f, 0.f, 1.f };
GfuiLabelSetColor(handle, errLabelID, col);
// Create buttons
GfuiButtonCreate(handle, "Accept", GFUI_FONT_MEDIUM, 365, 200, 50, GFUI_ALIGN_HC_VC, 0, ts, PAcceptCallback, nullptr, nullptr, nullptr);
GfuiButtonCreate(handle, "Cancel", GFUI_FONT_MEDIUM, 245, 200, 50, GFUI_ALIGN_HC_VC, 0, ts, PAcceptCallback, nullptr, nullptr, nullptr);
GfuiScreenActivate(handle);
}
// Save the choosen values in the corresponding parameter file.
static void saveSoundOption(void *)
{
const int BUFSIZE = 1024;
char buf[BUFSIZE];
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GR_SOUND_PARM_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfParmSetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[curOption]);
GfParmSetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", VolumeValue);
GfParmWriteFile(NULL, paramHandle, "sound");
GfParmReleaseHandle(paramHandle);
// Write Menu music optons
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), MM_SOUND_PARM_CFG);
paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfParmSetStr(paramHandle, MM_SCT_SOUND, MM_ATT_SOUND_ENABLE, menuMusicList[curOptionMenuMusic]);
GfParmWriteFile(NULL, paramHandle, "sound");
GfParmReleaseHandle(paramHandle);
if (curOptionMenuMusic == 1) {
startMenuMusic();
} else {
stopMenuMusic();
}
// Return to previous screen.
GfuiScreenActivate(prevHandle);
return;
}
void GfuiMenuScreen::runMenu()
{
if (!m_priv->xmlDescParmHdle && !openXMLDescriptor())
return;
GfuiScreenActivate(m_priv->menuHdle);
}
void LegacyMenu::onRaceStarted()
{
// Shutdown the loading screen if not already done.
shutdownLoadingScreen();
// Activate the game screen.
GfuiScreenActivate(_hscrGame);
}
static void
rmNetworkClientDisconnect(void * /* dummy */)
{
GfOut("Disconnecting from server\n");
if (NetGetClient())
NetGetClient()->Disconnect();
GfuiScreenActivate(RmRaceSelectMenuHandle);
}
static void
rmrpDeactivate(void *screen)
{
GfuiScreenRelease(scrHandle);
if (screen) {
GfuiScreenActivate(screen);
}
}
static void rmtsDeactivate(void *screen)
{
GfuiScreenRelease(scrHandle);
GfDirFreeList(CategoryList, rmtsFreeLists, true, true);
if (screen) {
GfuiScreenActivate(screen);
}
}
static void
onNext(void * /* dummy */)
{
int index;
/* Release up and running joysticks */
for (index = 0; index < GFCTRL_JOY_NUMBER; index++)
if (Joystick[index]) {
delete Joystick[index];
Joystick[index] = 0;
}
/* Back to previous screen */
if (CalState == NbCalSteps && NextMenuHandle != NULL)
GfuiScreenActivate(NextMenuHandle);
else
GfuiScreenActivate(PrevMenuHandle);
}
static void
rmDeactivate(void * /* dummy */ )
{
if (FileList) {
GfDirFreeList(FileList, NULL);
FileList = NULL;
}
GfuiScreenActivate(rmFs->prevScreen);
}
static void
rmNetworkServerDisconnect(void * /* dummy */)
{
GfLogInfo("Disconnecting all clients\n");
if (NetGetServer())
NetGetServer()->Disconnect();
GfuiScreenActivate(RmRaceSelectMenuHandle);
}
/* Return from interactive pit information */
static void
ReUpdtPitCmd(void *pvcar)
{
tCarElt *car = (tCarElt*)pvcar;
ReUpdtPitTime(car);
//ReStart(); /* resynchro */
GfuiScreenActivate(ReInfo->_reGameScreen);
}
/** Activate a screen and make it current plus release the current screen.
@ingroup gui
@param screen Screen to activate
@warning The current screen at the call time is deactivated.
*/
void
GfuiScreenReplace(void *screen)
{
tGfuiScreen *oldScreen = GfuiScreen;
if (oldScreen) {
GfuiScreenRelease(oldScreen);
}
GfuiScreenActivate(screen);
}
static void
rmdsDeactivate(void *screen)
{
rmFreeDrvList();
GfuiScreenRelease(scrHandle);
if (screen) {
GfuiScreenActivate(screen);
}
}
static void
AbandonRaceHookActivate(void * /* vforce */)
{
// Shutdown current event.
ReEventShutdown();
/* Return to race menu */
ReInfo->_reState = RE_STATE_CONFIG;
GfuiScreenActivate(ReInfo->_reGameScreen);
}
/** File selection
@param vs Pointer on tRmFileSelect structure (cast to void)
@return none
*/
void
RmFileSelect(void *vs)
{
tFList *FileCur;
rmFs = (tRmFileSelect*)vs;
if (scrHandle) {
GfuiScreenRelease(scrHandle);
}
scrHandle = GfuiScreenCreateEx((float*)NULL, NULL, rmActivate, NULL, (tfuiCallback)NULL, 1);
GfuiScreenAddBgImg(scrHandle, "data/img/splash-filesel.png");
GfuiTitleCreate(scrHandle, rmFs->title, 0);
/* Scroll List containing the File list */
fileScrollList = GfuiScrollListCreate(scrHandle, GFUI_FONT_MEDIUM_C, 120, 80, GFUI_ALIGN_HC_VB,
400, 310, GFUI_SB_RIGHT, NULL, rmClickOnFile);
FileList = GfDirGetList(rmFs->path);
if (FileList == NULL) {
GfuiScreenActivate(rmFs->prevScreen);
return;
}
FileSelected = FileList;
FileCur = FileList;
do {
FileCur = FileCur->next;
GfuiScrollListInsertElement(scrHandle, fileScrollList, FileCur->name, 1000, (void*)FileCur);
} while (FileCur != FileList);
/* Bottom buttons */
GfuiButtonCreate(scrHandle, "Select", GFUI_FONT_LARGE, 210, 40, 150, GFUI_ALIGN_HC_VB, GFUI_MOUSE_UP,
NULL, rmSelect, NULL, (tfuiCallback)NULL, (tfuiCallback)NULL);
GfuiButtonCreate(scrHandle, "Cancel", GFUI_FONT_LARGE, 430, 40, 150, GFUI_ALIGN_HC_VB, GFUI_MOUSE_UP,
NULL, rmDeactivate, NULL, (tfuiCallback)NULL, (tfuiCallback)NULL);
/* Default menu keyboard actions */
GfuiMenuDefaultKeysAdd(scrHandle);
GfuiScreenActivate(scrHandle);
}
int
ReRacemanMenu(void)
{
char *str;
void *params = ReInfo->params;
if (racemanMenuHdle) {
GfuiScreenRelease(racemanMenuHdle);
}
racemanMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL,
NULL, (tfuiCallback)NULL,
1);
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
if (str) {
GfuiScreenAddBgImg(racemanMenuHdle, str);
}
GfuiMenuDefaultKeysAdd(racemanMenuHdle);
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0);
if (str) {
GfuiTitleCreate(racemanMenuHdle, str, strlen(str));
}
GfuiMenuButtonCreate(racemanMenuHdle,
"New Race", "Start a New Race",
NULL, ReStartNewRace);
GfuiMenuButtonCreate(racemanMenuHdle,
"Configure Race", "Configure The Race",
NULL, reConfigureMenu);
/* GfuiMenuButtonCreate(racemanMenuHdle, */
/* "Configure Players", "Players configuration menu", */
/* TorcsDriverMenuInit(racemanMenuHdle), GfuiScreenActivate); */
if (GfParmGetEltNb(params, RM_SECT_TRACKS) > 1) {
GfuiMenuButtonCreate(racemanMenuHdle,
"Load", "Load a Previously Saved Game",
racemanMenuHdle, reLoadMenu);
}
GfuiMenuBackQuitButtonCreate(racemanMenuHdle,
"Back to Main", "Return to previous Menu",
ReInfo->_reMenuScreen, GfuiScreenActivate);
GfuiScreenActivate(racemanMenuHdle);
return RM_ASYNC | RM_NEXT_STEP;
}
int
ReNewTrackMenu(void)
{
void *params = ReInfo->params;
void *results = ReInfo->results;
if (newTrackMenuHdle) {
GfuiScreenRelease(newTrackMenuHdle);
}
newTrackMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL,
NULL, (tfuiCallback)NULL,
1);
const char* str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
if (str) {
GfuiScreenAddBgImg(newTrackMenuHdle, str);
}
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, "");
GfuiTitleCreate(newTrackMenuHdle, str, strlen(str));
GfuiMenuDefaultKeysAdd(newTrackMenuHdle);
sprintf(buf, "Race Day #%d/%d on %s",
(int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1),
GfParmGetEltNb(params, RM_SECT_TRACKS),
ReInfo->track->name);
GfuiLabelCreateEx(newTrackMenuHdle,
buf,
red,
GFUI_FONT_MEDIUM_C,
320, 420,
GFUI_ALIGN_HC_VB, 50);
GfuiMenuButtonCreate(newTrackMenuHdle,
"Start Event", "Start The Current Race",
NULL, reStateManage);
GfuiMenuButtonCreate(newTrackMenuHdle,
"Abandon", "Abandon The Race",
ReInfo->_reMenuScreen, GfuiScreenActivate);
GfuiAddKey(newTrackMenuHdle, 27, "Abandon", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
GfuiScreenActivate(newTrackMenuHdle);
return RM_ASYNC | RM_NEXT_STEP;
}
/* Activate the control config screen if a player is selected */
static void
onConfControls(void * /* dummy */ )
{
unsigned curPlayerIdx;
if (CurrPlayer != PlayersInfo.end()) {
ReloadValues = 0;
curPlayerIdx = (unsigned)(CurrPlayer - PlayersInfo.begin()) + 1;
GfuiScreenActivate(ControlMenuInit(ScrHandle, PrefHdle, curPlayerIdx, (*CurrPlayer)->gearChangeMode(), 0));
}
}
/* Save the choosen values in the corresponding parameter file */
static void SaveSimuVersion(void * /* dummy */)
{
char buf[1024];
snprintf(buf, 1024, "%s%s", GetLocalDir(), RACE_ENG_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfParmSetStr(paramHandle, "Modules", "simu", simuVersionList[curVersion]);
GfParmWriteFile(NULL, paramHandle, "raceengine");
GfParmReleaseHandle(paramHandle);
/* return to previous screen */
GfuiScreenActivate(prevHandle);
return;
}
// Save the choosen values in the corresponding parameter file.
static void saveSoundOption(void *)
{
char buf[1024];
sprintf(buf, "%s%s", GetLocalDir(), GR_SOUND_PARM_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfParmSetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[curOption]);
GfParmSetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", VolumeValue);
GfParmWriteFile(NULL, paramHandle, "sound");
GfParmReleaseHandle(paramHandle);
// Return to previous screen.
GfuiScreenActivate(prevHandle);
return;
}
// Generic function for creating and activating the menu.
static void*
rmStopRaceMenu(const tButtonDesc aButtons[], int nButtons, int nCancelIndex)
{
// Create screen, load menu XML descriptor and create static controls.
void *hscreen = GfuiScreenCreate(NULL, NULL, NULL, NULL, NULL, 1);
void *hmenu = GfuiMenuLoad("stopracemenu.xml");
GfuiMenuCreateStaticControls(hscreen, hmenu);
// Create buttons from menu properties and button template.
const int xpos = (int)GfuiMenuGetNumProperty(hmenu, "xButton", 270);
const int dy = (int)GfuiMenuGetNumProperty(hmenu, "buttonShift", 30);
int ypos = (int)GfuiMenuGetNumProperty(hmenu, "yTopButton", 380);
char pszPropName[64];
const char* pszCancelTip = "";
for (int nButInd = 0; nButInd < nButtons; nButInd++)
{
// Get text and tip from button role and menu properties.
sprintf(pszPropName, "%s.text", aButtons[nButInd].role);
const char* pszText = GfuiMenuGetStrProperty(hmenu, pszPropName, "");
sprintf(pszPropName, "%s.tip", aButtons[nButInd].role);
const char* pszTip = GfuiMenuGetStrProperty(hmenu, pszPropName, "");
if (nButInd == nCancelIndex)
pszCancelTip = pszTip;
// Create the button from the template.
GfuiMenuCreateTextButtonControl(hscreen, hmenu, "button",
aButtons[nButInd].screen, GfuiScreenActivate, 0, 0, 0,
true, // From template.
pszText, pszTip, xpos, ypos);
// Next button if not last.
ypos -= dy;
}
// Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(hscreen);
GfuiAddKey(hscreen, GFUIK_ESCAPE, pszCancelTip,
aButtons[nCancelIndex].screen, GfuiScreenActivate, NULL);
// Close menu XML descriptor.
GfParmReleaseHandle(hmenu);
// Activate the created screen.
GfuiScreenActivate(hscreen);
return hscreen;
}
/* Save the choosen values in the corresponding parameter file */
static void storeSimuCfg(void * /* dummy */)
{
char buf[1024];
snprintf(buf, sizeof(buf), "%s%s", GfLocalDir(), RACE_ENG_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfParmSetStr(paramHandle, RM_SECT_MODULES, RM_ATTR_MOD_SIMU, SimuVersionList[CurSimuVersion]);
GfParmSetStr(paramHandle, RM_SECT_RACE_ENGINE, RM_ATTR_MULTI_THREADING, MultiThreadSchemeList[CurMultiThreadScheme]);
GfParmSetStr(paramHandle, RM_SECT_RACE_ENGINE, RM_ATTR_THREAD_AFFINITY, ThreadAffinitySchemeList[CurThreadAffinityScheme]);
GfParmWriteFile(NULL, paramHandle, "raceengine");
GfParmReleaseHandle(paramHandle);
/* return to previous screen */
GfuiScreenActivate(PrevScrHandle);
return;
}
static void
AbortRaceHookActivate(void * /* dummy */)
{
GfuiScreenActivate(ReInfo->_reGameScreen);
ReInfo->_reSimItf.shutdown();
if (ReInfo->_displayMode == RM_DISP_MODE_NORMAL) {
ReInfo->_reGraphicItf.shutdowncars();
startMenuMusic();
}
ReInfo->_reGraphicItf.shutdowntrack();
ReRaceCleanDrivers();
taManager->RaceEnd();
FREEZ(ReInfo->_reCarInfo);
/* Return to race menu */
ReInfo->_reState = RE_STATE_CONFIG;
}
static void onAccept(void *)
{
// Store current state of settings to the GL features layer.
GfglFeatures::self().select(GfglFeatures::TextureCompression,
strcmp(ATextureCompTexts[NCurTextureCompIndex],
GFSCR_ATT_TEXTURECOMPRESSION_ENABLED) ? false : true);
GfglFeatures::self().select(GfglFeatures::TextureMaxSize,
AMaxTextureSizeTexts[NCurMaxTextureSizeIndex]);
GfglFeatures::self().select(GfglFeatures::MultiTexturing,
strcmp(AMultiTextureTexts[NCurMultiTextureIndex],
GFSCR_ATT_MULTITEXTURING_ENABLED) ? false : true);
GfglFeatures::self().select(GfglFeatures::MultiSampling,
VecMultiSampleTexts[NCurMultiSampleIndex]
!= GFSCR_ATT_MULTISAMPLING_DISABLED);
if (VecMultiSampleTexts[NCurMultiSampleIndex] != GFSCR_ATT_MULTISAMPLING_DISABLED)
GfglFeatures::self().select(GfglFeatures::MultiSamplingSamples,
(int)pow(2.0, (double)NCurMultiSampleIndex));
GfglFeatures::self().select(GfglFeatures::BumpMapping, strcmp(ABumpMappingTexts[NCurBumpMappingIndex],
GFSCR_ATT_BUMPMAPPING_ENABLED) ? false : true);
GfglFeatures::self().select(GfglFeatures::AnisotropicFiltering, NCurAnisotropicFilteringIndex);
// Store settings from the GL features layer to the screen.xml file.
GfglFeatures::self().storeSelection();
// Return to previous screen.
GfuiScreenActivate(PrevHandle);
// But actually restart the game if the multi-sampling feature settings changed
// (we can't change this without re-initializing the video mode).
if (GfglFeatures::self().isSelected(GfglFeatures::MultiSampling) != BMultiSamplingWasSelected
|| GfglFeatures::self().getSelected(GfglFeatures::MultiSamplingSamples) != BPrevMultiSamplingSamples)
{
// Shutdown the user interface.
LegacyMenu::self().shutdown();
// Restart the game.
GfuiApp().restart();
}
}
void
RmNetworkMenu(void *)
{
GfLogTrace("Entering Network menu.\n");
tRmInfo* reInfo = LmRaceEngine().inData();
void *params = reInfo->params;
if (NetGetNetwork())
{
NetGetNetwork()->ResetNetwork();
}
racemanMenuHdle = GfuiScreenCreate(NULL, NULL, (tfuiCallback)NULL,
NULL, (tfuiCallback)NULL, 1);
void *mparam = GfuiMenuLoad("networkmenu.xml");
GfuiMenuCreateStaticControls(racemanMenuHdle, mparam);
const int nTitleLabelId = GfuiMenuCreateLabelControl(racemanMenuHdle, mparam, "TitleLabel");
const char* pszTitle = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0);
if (pszTitle)
GfuiLabelSetText(racemanMenuHdle, nTitleLabelId, pszTitle);
GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "HostButton",
0, RmNetworkHostMenu);
GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "JoinButton",
0, NetworkClientConnectMenu);
GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "BackButton",
RmRaceSelectMenuHandle, GfuiScreenActivate);
GfuiMenuDefaultKeysAdd(racemanMenuHdle);
GfuiAddKey(racemanMenuHdle, GFUIK_ESCAPE, "Back to previous menu",
RmRaceSelectMenuHandle, 0, GfuiScreenActivate);
GfParmReleaseHandle(mparam);
GfuiScreenActivate(racemanMenuHdle);
}
static void
ShowWaitingToConnectScreen()
{
GfLogTrace("Entering Network Wait Connection menu.\n");
if (racemanMenuHdle)
GfuiScreenRelease(racemanMenuHdle);
racemanMenuHdle = GfuiScreenCreate(NULL, NULL, (tfuiCallback) NULL,
NULL, (tfuiCallback)NULL, 1);
void *mparam = GfuiMenuLoad("networkwaitconnectmenu.xml");
GfuiMenuCreateStaticControls(racemanMenuHdle, mparam);
GfuiMenuDefaultKeysAdd(racemanMenuHdle);
GfuiScreenActivate(racemanMenuHdle);
GfuiApp().eventLoop().postRedisplay();
}
