iceflower/speed-dreams-code
1
0
Fork 0
forked from speed-dreams/speed-dreams-code
Code Pull requests Activity

Re #197 (D31 : Save and restore Quick Race) : First up-and-running try

Browse source 
git-svn-id: https://svn.code.sf.net/p/speed-dreams/code/trunk@2900 30fe4595-0a0c-4342-8851-515496e4dcbd

Former-commit-id: 4f851d7f9993a37b2ef61aee121d0032cd9bb891
Former-commit-id: 5ba5c6442f5b1ade00a8af7a0dcdc04297eac2cd
This commit is contained in:
pouillot 2010-10-16 17:35:44 +00:00
parent 1e0fdc155d
commit b599a23320
5 changed files with 543 additions and 347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

79
src/libs/raceengineclient/raceinit.cpp
View file

@ -56,7 +56,12 @@
static const char *level_str[] = { ROB_VAL_ROOKIE, ROB_VAL_AMATEUR, ROB_VAL_SEMI_PRO, ROB_VAL_PRO }; static const char *level_str[] = { ROB_VAL_ROOKIE, ROB_VAL_AMATEUR, ROB_VAL_SEMI_PRO, ROB_VAL_PRO };
static tModList *reEventModList = 0; static tModList *reEventModList = 0;
tModList *ReRaceModList = 0; tModList *ReRaceModList = 0;
tFList *ReRacemanList;
static char buf[1024]; static char buf[1024];
static char path[1024]; static char path[1024];
@ -167,14 +172,17 @@ ReStartNewRace(void * /* dummy */)
/* Launch a race manager */ /* Launch a race manager */
static void reSelectRaceman(void *params) static void reSelectRaceman(void *pRaceman)
{ {
char *s, *e, *m; char *s, *e, *m;
GfTrace("Selecting %s race type\n", GfParmGetName(params)); void* params = ((tFList*)pRaceman)->userData;
ReInfo->params = params; ReInfo->params = params;
ReInfo->mainParams = params; ReInfo->mainParams = params;
ReInfo->_reName = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, "");
// Set new file name.
FREEZ(ReInfo->_reFilename); FREEZ(ReInfo->_reFilename);
s = GfParmGetFileName(params); s = GfParmGetFileName(params);
@ -183,11 +191,12 @@ static void reSelectRaceman(void *params)
} }
e = strstr(s, PARAMEXT); e = strstr(s, PARAMEXT);
//This line doesn't compile with MSVC ReInfo->_reFilename = strdup(s); // "strndup(s, e-s+1)" doesn't compile with MSVC.
//ReInfo->_reFilename = strndup(s, e-s+1);
ReInfo->_reFilename = strdup(s);
ReInfo->_reFilename[e-s] = '\0'; ReInfo->_reFilename[e-s] = '\0';
ReInfo->_reName = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, "");
GfLogTrace("%s selected\n", GfParmGetName(params));
// Enter CONFIG state.
ReStateApply(RE_STATE_CONFIG); ReStateApply(RE_STATE_CONFIG);
} }
@ -210,6 +219,24 @@ reRegisterRaceman(tFList *racemanCur)
racemanCur->dispName = GfParmGetStrNC(racemanCur->userData, RM_SECT_HEADER, RM_ATTR_NAME, 0); racemanCur->dispName = GfParmGetStrNC(racemanCur->userData, RM_SECT_HEADER, RM_ATTR_NAME, 0);
} }
// Update the given raceman infos.
void
ReUpdateRaceman(const char* pszFileName, void* params)
{
tFList *racemanCur;
racemanCur = ReRacemanList;
do {
if (strcmp(pszFileName, racemanCur->name))
{
racemanCur->userData = params;
break;
}
racemanCur = racemanCur->next;
} while (racemanCur != ReRacemanList);
GfLogError("Failed to update params pointer for %s\n", pszFileName);
}
/* Sort race managers by priority */ /* Sort race managers by priority */
static void static void
reSortRacemanList(tFList **racemanList) reSortRacemanList(tFList **racemanList)
@ -249,47 +276,33 @@ reSortRacemanList(tFList **racemanList)
/* Load race managers selection menu */ /* Load race managers selection menu */
void ReAddRacemanListButton(void *menuHandle, void *menuXMLDescHandle) void ReAddRacemanListButton(void *menuHandle, void *menuXMLDescHandle)
{ {
tFList *racemanList;
tFList *racemanCur; tFList *racemanCur;
racemanList = GfDirGetListFiltered("config/raceman", "", ".xml"); // Create racemans list from <user settings>/config/raceman/*.xml folder
if (!racemanList) { ReRacemanList = GfDirGetListFiltered("config/raceman", "", PARAMEXT);
if (!ReRacemanList) {
GfError("No race manager available\n"); GfError("No race manager available\n");
return; return;
} }
racemanCur = racemanList; // Complete the raceman list : load the race configuration for each raceman.
racemanCur = ReRacemanList;
do { do {
reRegisterRaceman(racemanCur); reRegisterRaceman(racemanCur);
racemanCur = racemanCur->next; racemanCur = racemanCur->next;
} while (racemanCur != racemanList); } while (racemanCur != ReRacemanList);
reSortRacemanList(&racemanList); // Sort the raceman list by priority.
reSortRacemanList(&ReRacemanList);
// Create 1 button for each race type. // Create 1 button for each raceman (= race type).
// TODO: Use menuXMLDescHandle to get buttons layout info, colors, ... // TODO: Use menuXMLDescHandle to get buttons layout info, colors, ...
racemanCur = racemanList; racemanCur = ReRacemanList;
do { do {
CreateButtonControl(menuHandle,menuXMLDescHandle,racemanCur->dispName,racemanCur->userData,reSelectRaceman); CreateButtonControl(menuHandle, menuXMLDescHandle, racemanCur->dispName,
/* racemanCur, reSelectRaceman);
GfuiMenuButtonCreate(menuHandle,
racemanCur->dispName,
GfParmGetStr(racemanCur->userData, RM_SECT_HEADER, RM_ATTR_DESCR, ""),
racemanCur->userData,
reSelectRaceman);
*/
racemanCur = racemanCur->next; racemanCur = racemanCur->next;
} while (racemanCur != racemanList); } while (racemanCur != ReRacemanList);
// The list contains at least one element, checked above.
tFList *rl = racemanList;
do {
tFList *tmp = rl;
rl = rl->next;
// Do not free userData and dispName, is in use.
freez(tmp->name);
free(tmp);
} while (rl != racemanList);
} }

1
src/libs/raceengineclient/raceinit.h
View file

@ -32,6 +32,7 @@
extern void ReInit(void); extern void ReInit(void);
extern void ReShutdown(void); extern void ReShutdown(void);
RACEENGINECLIENT_API void ReStartNewRace(void * /* dummy */); RACEENGINECLIENT_API void ReStartNewRace(void * /* dummy */);
extern void ReUpdateRaceman(const char* pszFileName, void* params);
extern void ReAddRacemanListButton(void *menuHandle, void *menuXMLDescHandle); extern void ReAddRacemanListButton(void *menuHandle, void *menuXMLDescHandle);
extern int ReInitCars(void); extern int ReInitCars(void);
extern int ReInitTrack(void); extern int ReInitTrack(void);

613
src/libs/raceengineclient/racemanmenu.cpp
View file

@ -2,9 +2,9 @@
file : racemanmenu.cpp file : racemanmenu.cpp
created : Fri Jan 3 22:24:41 CET 2003 created : Fri Jan 3 22:24:41 CET 2003
copyright : (C) 2003 by Eric Espi<EFBFBD> copyright : (C) 2003 by Eric Espie
email : eric.espie@torcs.org email : eric.espie@torcs.org
version : $Id: racemanmenu.cpp,v 1.5 2004/08/11 17:44:06 torcs Exp $ version : $Id: racemanmenu.cpp,v 1.5 2004/08/11 17:44:06 torcs $
***************************************************************************/ ***************************************************************************/
@ -20,7 +20,7 @@
/** @file /** @file
@author <a href=mailto:eric.espie@torcs.org>Eric Espie</a> @author <a href=mailto:eric.espie@torcs.org>Eric Espie</a>
@version $Id: racemanmenu.cpp,v 1.5 2004/08/11 17:44:06 torcs Exp $ @version $Id: racemanmenu.cpp,v 1.5 2004/08/11 17:44:06 torcs $
*/ */
#include <cstdlib> #include <cstdlib>
@ -41,9 +41,16 @@
#include "networkingmenu.h" #include "networkingmenu.h"
// Raceman menu.
static void *RacemanMenuHdle = NULL;
static int TitleLabelId = 0;
static int LoadRaceButtonId = 0;
static int SaveRaceButtonId = 0;
// New track menu.
static void *NewTrackMenuHdle = NULL;
static void *racemanMenuHdle = NULL;
static void *newTrackMenuHdle = NULL;
static tRmTrackSelect ts; static tRmTrackSelect ts;
static tRmDriverSelect ds; static tRmDriverSelect ds;
static tRmRaceParam rp; static tRmRaceParam rp;
@ -55,13 +62,13 @@ static void reConfigRunState(void);
static void static void
reConfigBack(void) reConfigBack(void)
{ {
void *params = ReInfo->params; void* params = ReInfo->params;
/* Go back one step in the conf */ /* Go back one step in the conf */
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL,
GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1) - 2); GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1) - 2);
reConfigRunState(); reConfigRunState();
} }
@ -72,19 +79,18 @@ static void *configHookHandle = 0;
static void static void
configHookActivate(void * /* dummy */) configHookActivate(void * /* dummy */)
{ {
reConfigRunState(); reConfigRunState();
} }
static void * static void *
reConfigHookInit(void) reConfigHookInit(void)
{ {
if (configHookHandle) { if (configHookHandle)
return configHookHandle;
configHookHandle = GfuiHookCreate(0, configHookActivate);
return configHookHandle; return configHookHandle;
}
configHookHandle = GfuiHookCreate(0, configHookActivate);
return configHookHandle;
} }
/***************************************************************/ /***************************************************************/
@ -95,182 +101,320 @@ static void *ConfigBackHookHandle = 0;
static void static void
ConfigBackHookActivate(void * /* dummy */) ConfigBackHookActivate(void * /* dummy */)
{ {
reConfigBack(); reConfigBack();
} }
static void * static void *
reConfigBackHookInit(void) reConfigBackHookInit(void)
{ {
if (ConfigBackHookHandle) { if (ConfigBackHookHandle)
return ConfigBackHookHandle;
ConfigBackHookHandle = GfuiHookCreate(0, ConfigBackHookActivate);
return ConfigBackHookHandle; return ConfigBackHookHandle;
}
ConfigBackHookHandle = GfuiHookCreate(0, ConfigBackHookActivate);
return ConfigBackHookHandle;
} }
static void static void
reConfigRunState(void) reConfigRunState(void)
{ {
char path[256]; char path[256];
int i; int i;
int curConf; int curConf;
const char *conf; const char *conf;
int numOpt; int numOpt;
const char *opt; const char *opt;
void *params = ReInfo->params; void *params = ReInfo->params;
curConf = (int)GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1); curConf = (int)GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
if (curConf > GfParmGetEltNb(params, RM_SECT_CONF)) { if (curConf > GfParmGetEltNb(params, RM_SECT_CONF)) {
GfOut("End of configuration\n"); GfLogInfo("%s configuration finished.\n", ReInfo->_reName);
GfParmWriteFile(NULL, ReInfo->params, ReInfo->_reName); GfParmWriteFile(NULL, ReInfo->params, ReInfo->_reName);
goto menuback; GfuiScreenActivate(RacemanMenuHdle); /* Back to the race menu */
} return;
sprintf(path, "%s/%d", RM_SECT_CONF, curConf);
conf = GfParmGetStr(params, path, RM_ATTR_TYPE, 0);
if (!conf) {
GfOut("no %s here %s\n", RM_ATTR_TYPE, path);
goto menuback;
}
GfOut("Configuration step %s\n", conf);
if (!strcmp(conf, RM_VAL_TRACKSEL)) {
/* Track Select Menu */
ts.nextScreen = reConfigHookInit();
if (curConf == 1) {
ts.prevScreen = racemanMenuHdle;
} else {
ts.prevScreen = reConfigBackHookInit();
} }
ts.param = ReInfo->params;
ts.trackItf = ReInfo->_reTrackItf; sprintf(path, "%s/%d", RM_SECT_CONF, curConf);
RmTrackSelect(&ts); conf = GfParmGetStr(params, path, RM_ATTR_TYPE, 0);
if (!conf) {
} else if (!strcmp(conf, RM_VAL_DRVSEL)) { GfLogError("No %s here (%s) !\n", RM_ATTR_TYPE, path);
/* Drivers select menu */ GfuiScreenActivate(RacemanMenuHdle); /* Back to the race menu */
ds.nextScreen = reConfigHookInit(); return;
if (curConf == 1) {
ds.prevScreen = racemanMenuHdle;
} else {
ds.prevScreen = reConfigBackHookInit();
} }
ds.param = ReInfo->params;
RmDriversSelect(&ds);
} else if (!strcmp(conf, RM_VAL_RACECONF)) { GfLogInfo("%s configuration now in '%s' stage.\n", ReInfo->_reName, conf);
/* Race Options menu */ if (!strcmp(conf, RM_VAL_TRACKSEL)) {
rp.nextScreen = reConfigHookInit(); /* Track Select Menu */
if (curConf == 1) { ts.nextScreen = reConfigHookInit();
rp.prevScreen = racemanMenuHdle; if (curConf == 1) {
} else { ts.prevScreen = RacemanMenuHdle;
rp.prevScreen = reConfigBackHookInit(); } else {
} ts.prevScreen = reConfigBackHookInit();
rp.param = ReInfo->params;
rp.title = GfParmGetStr(params, path, RM_ATTR_RACE, "Race");
/* Select options to configure */
rp.confMask = 0;
sprintf(path, "%s/%d/%s", RM_SECT_CONF, curConf, RM_SECT_OPTIONS);
numOpt = GfParmGetEltNb(params, path);
for (i = 1; i < numOpt + 1; i++) {
sprintf(path, "%s/%d/%s/%d", RM_SECT_CONF, curConf, RM_SECT_OPTIONS, i);
opt = GfParmGetStr(params, path, RM_ATTR_TYPE, "");
if (!strcmp(opt, RM_VAL_CONFRACELEN)) {
/* Configure race length */
rp.confMask |= RM_CONF_RACE_LEN;
} else {
if (!strcmp(opt, RM_VAL_CONFDISPMODE)) {
/* Configure display mode */
rp.confMask |= RM_CONF_DISP_MODE;
} }
} ts.param = ReInfo->params;
ts.trackItf = ReInfo->_reTrackItf;
RmTrackSelect(&ts);
} else if (!strcmp(conf, RM_VAL_DRVSEL)) {
/* Drivers select menu */
ds.nextScreen = reConfigHookInit();
if (curConf == 1) {
ds.prevScreen = RacemanMenuHdle;
} else {
ds.prevScreen = reConfigBackHookInit();
}
ds.param = ReInfo->params;
RmDriversSelect(&ds);
} else if (!strcmp(conf, RM_VAL_RACECONF)) {
/* Race Options menu */
rp.nextScreen = reConfigHookInit();
if (curConf == 1) {
rp.prevScreen = RacemanMenuHdle;
} else {
rp.prevScreen = reConfigBackHookInit();
}
rp.param = ReInfo->params;
rp.title = GfParmGetStr(params, path, RM_ATTR_RACE, "Race");
/* Select options to configure */
rp.confMask = 0;
sprintf(path, "%s/%d/%s", RM_SECT_CONF, curConf, RM_SECT_OPTIONS);
numOpt = GfParmGetEltNb(params, path);
for (i = 1; i < numOpt + 1; i++) {
sprintf(path, "%s/%d/%s/%d", RM_SECT_CONF, curConf, RM_SECT_OPTIONS, i);
opt = GfParmGetStr(params, path, RM_ATTR_TYPE, "");
if (!strcmp(opt, RM_VAL_CONFRACELEN)) {
/* Configure race length */
rp.confMask |= RM_CONF_RACE_LEN;
} else {
if (!strcmp(opt, RM_VAL_CONFDISPMODE)) {
/* Configure display mode */
rp.confMask |= RM_CONF_DISP_MODE;
}
}
}
RmRaceParamMenu(&rp);
} }
RmRaceParamMenu(&rp);
}
curConf++; curConf++;
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, curConf); GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, curConf);
return;
/* Back to the race menu */
menuback:
GfuiScreenActivate(racemanMenuHdle);
return;
} }
void ReSetRacemanMenuHandle( void * handle) void ReSetRacemanMenuHandle(void * handle)
{ {
racemanMenuHdle = handle; RacemanMenuHdle = handle;
} }
void void
ReConfigureMenu(void * /* dummy */) ReConfigureMenu(void * /* dummy */)
{ {
void *params = ReInfo->params; void *params = ReInfo->params;
/* Reset configuration automaton */ /* Reset configuration automaton */
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1); GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
reConfigRunState(); reConfigRunState();
} }
static void static void
reSelectResultsFile(char *filename) reLoadRaceFromResultsFile(const char *filename)
{ {
char buf[512]; char buf[256];
sprintf(buf, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename); sprintf(buf, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename);
GfLogInfo("Loading saved race from %s ...\n", buf); GfLogInfo("Loading saved race from %s ...\n", buf);
ReInfo->mainResults = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
ReInfo->results = ReInfo->mainResults; // Update race data.
ReInfo->_reRaceName = ReInfo->_reName; ReInfo->mainResults = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
GfParmRemoveVariable (ReInfo->params, "/", "humanInGroup"); ReInfo->results = ReInfo->mainResults;
GfParmSetVariable (ReInfo->params, "/", "humanInGroup", ReHumanInGroup() ? 1 : 0); ReInfo->_reRaceName = ReInfo->_reName;
RmShowStandings(ReInfo->_reGameScreen, ReInfo);
GfParmRemoveVariable (ReInfo->params, "/", "humanInGroup");
GfParmSetVariable (ReInfo->params, "/", "humanInGroup", ReHumanInGroup() ? 1 : 0);
// Fire standings screen.
RmShowStandings(ReInfo->_reGameScreen, ReInfo);
} }
static void static void
reFileSelectMenu(void *prevHandle) reLoadRaceFromConfigFile(const char *filename)
{ {
char buf[512]; char pszSelFilePathName[256];
sprintf(pszSelFilePathName, "%sconfig/raceman/%s/%s",
GetLocalDir(), ReInfo->_reFilename, filename);
GfLogInfo("Loading saved race from %s ...\n", pszSelFilePathName);
const char *str; // Replace the main race file by the selected one.
void *params = ReInfo->params; char pszMainFilePathName[256];
sprintf(pszMainFilePathName, "%sconfig/raceman/%s%s",
GetLocalDir(), ReInfo->_reFilename, PARAMEXT);
if (!GfFileCopy(pszSelFilePathName, pszMainFilePathName))
{
GfLogError("Failed to load selected race file %s", pszSelFilePathName);
return;
}
// Update race data.
GfParmReleaseHandle(ReInfo->params);
ReInfo->mainParams = ReInfo->params = GfParmReadFile(pszMainFilePathName, GFPARM_RMODE_STD);
ReInfo->_reName = GfParmGetStr(ReInfo->params, RM_SECT_HEADER, RM_ATTR_NAME, "");
ReInfo->_reRaceName = ReInfo->_reName;
GfParmRemoveVariable (ReInfo->params, "/", "humanInGroup");
GfParmSetVariable (ReInfo->params, "/", "humanInGroup", ReHumanInGroup() ? 1 : 0);
fs.prevScreen = prevHandle; // Update raceman info (the params pointer changed).
fs.select = reSelectResultsFile; char pszFileName[64];
sprintf(pszFileName, "%s%s", ReInfo->_reFilename, PARAMEXT);
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0); ReUpdateRaceman(pszFileName, ReInfo->params);
if (str) {
fs.title = str;
}
sprintf(buf, "%sresults/%s", GetLocalDir(), ReInfo->_reFilename);
fs.path = buf;
RmFileSelect((void*)&fs);
} }
static void static void
rePlayerConfig(void * /* dummy */) reSaveRaceToConfigFile(const char *filename)
{ {
/* Here, we need to call OptionOptionInit each time the firing button // Note: No need to write the main file here, already done at the end of race configuration.
is pressed, and not only once at the Raceman menu initialization, char pszMainFilePathName[256];
because the previous menu has to be saved (ESC, Back) and because it can be this menu, sprintf(pszMainFilePathName, "%sconfig/raceman/%s%s",
as well as the Main menu */ GetLocalDir(), ReInfo->_reFilename, PARAMEXT);
GfuiScreenActivate(PlayerConfigMenuInit(racemanMenuHdle));
// Add .xml extension if not there.
char pszSelFilePathName[256];
sprintf(pszSelFilePathName, "%sconfig/raceman/%s/%s",
GetLocalDir(), ReInfo->_reFilename, filename);
const char* pszFileExt = strrchr(pszSelFilePathName, '.');
if (!pszFileExt || strcmp(pszFileExt, PARAMEXT))
strcat(pszSelFilePathName, PARAMEXT);
// Copy the main file to the selected one (overwrite if already there).
GfLogInfo("Saving race config to %s ...\n", pszSelFilePathName);
if (!GfFileCopy(pszMainFilePathName, pszSelFilePathName))
GfLogError("Failed to save race to selected config file %s", pszSelFilePathName);
}
static void
reOnPlayerConfig(void * /* dummy */)
{
/* Here, we need to call OptionOptionInit each time the firing button
is pressed, and not only once at the Raceman menu initialization,
because the previous menu has to be saved (ESC, Back) and because it can be this menu,
as well as the Main menu */
GfuiScreenActivate(PlayerConfigMenuInit(RacemanMenuHdle));
}
static char*
reGetLoadFileDir(char* pszDirPath, int nMaxLen)
{
void *params = ReInfo->params;
// For race types with more than 1 event (= 1 race on 1 track), load a race result file,
// as the previous race standings has an influence on the next race starting grid.
if (GfParmGetEltNb(params, RM_SECT_TRACKS) > 1)
snprintf(pszDirPath, nMaxLen, "%sresults/%s", GetLocalDir(), ReInfo->_reFilename);
// But for race types with only 1 event (= 1 race on 1 track), load a race config file.
else
snprintf(pszDirPath, nMaxLen, "%sconfig/raceman/%s", GetLocalDir(), ReInfo->_reFilename);
return pszDirPath;
}
static void
reOnLoadRaceFromFile(void *pPrevMenu)
{
void *params = ReInfo->params;
fs.title = ReInfo->_reName;
fs.prevScreen = pPrevMenu;
fs.mode = RmFSModeLoad;
char pszDirPath[256];
fs.path = reGetLoadFileDir(pszDirPath, 256);
// For race types with more than 1 event (= 1 race on 1 track), load a race result file,
// as the previous race standings has an influence on the next race starting grid.
if (GfParmGetEltNb(params, RM_SECT_TRACKS) > 1)
fs.select = reLoadRaceFromResultsFile;
// But for race types with only 1 event (= 1 race on 1 track), load a race config file.
else
fs.select = reLoadRaceFromConfigFile;
// Fire the file selection menu.
GfuiScreenActivate(RmFileSelect(&fs));
}
static void
reOnSaveRaceToFile(void *pPrevMenu)
{
void *params = ReInfo->params;
// Fill-in file selection descriptor
fs.title = ReInfo->_reName;
fs.prevScreen = pPrevMenu;
fs.mode = RmFSModeSave;
char pszDirPath[256];
snprintf(pszDirPath, 256, "%sconfig/raceman/%s", GetLocalDir(), ReInfo->_reFilename);
fs.path = pszDirPath;
fs.select = reSaveRaceToConfigFile;
// Fire the file selection menu.
GfuiScreenActivate(RmFileSelect(&fs));
}
static bool
reCanLoadRace()
{
void *params = ReInfo->params;
// Determine the source folder.
char pszDirPath[256];
reGetLoadFileDir(pszDirPath, 256);
// Get the list of files in the target folder.
tFList *pFileList = GfDirGetListFiltered(pszDirPath, "", PARAMEXT);
// Now we know what to answer.
const bool bAnswer = (pFileList != 0);
// Free the file list.
GfDirFreeList(pFileList, 0, true, true);
// Answer.
return bAnswer;
}
static bool
reCanSaveRace()
{
void *params = ReInfo->params;
// Multi-events race types are automatically saved in config/raceman/results
return GfParmGetEltNb(params, RM_SECT_TRACKS) == 1;
}
static void
reOnActivate(void * /* dummy */)
{
void *params = ReInfo->params;
// Set title.
GfuiLabelSetText(RacemanMenuHdle, TitleLabelId, ReInfo->_reName);
// Show Load/Save race buttons as needed.
GfuiVisibilitySet(RacemanMenuHdle, LoadRaceButtonId,
reCanLoadRace() ? GFUI_VISIBLE : GFUI_INVISIBLE);
GfuiVisibilitySet(RacemanMenuHdle, SaveRaceButtonId,
reCanSaveRace() ? GFUI_VISIBLE : GFUI_INVISIBLE);
} }
int int
ReRacemanMenu(void) ReRacemanMenu(void)
{ {
const char *str; void *params = ReInfo->params;
void *params = ReInfo->params;
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0); if (strcmp(ReInfo->_reName,"Online Race")==0)
if (strcmp(str,"Online Race")==0) {
{
if (GetNetwork()) if (GetNetwork())
{ {
if (GetNetwork()->IsConnected()) if (GetNetwork()->IsConnected())
@ -293,125 +437,126 @@ ReRacemanMenu(void)
return RM_ASYNC | RM_NEXT_STEP; return RM_ASYNC | RM_NEXT_STEP;
} }
} }
if (racemanMenuHdle) { if (RacemanMenuHdle)
GfuiScreenRelease(racemanMenuHdle); GfuiScreenRelease(RacemanMenuHdle);
}
// Create screen, load menu XML descriptor and create static controls. // Create screen, load menu XML descriptor and create static controls.
racemanMenuHdle = GfuiScreenCreateEx(NULL, RacemanMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL, NULL, reOnActivate,
NULL, (tfuiCallback)NULL, NULL, (tfuiCallback)NULL,
1); 1);
void *menuXMLDescHdle = LoadMenuXML("racechoicemenu.xml"); void *menuXMLDescHdle = LoadMenuXML("racemanmenu.xml");
CreateStaticControls(menuXMLDescHdle,racemanMenuHdle);
CreateStaticControls(menuXMLDescHdle, RacemanMenuHdle);
// Create variable title label. // Create variable title label.
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0); TitleLabelId = CreateLabelControl(RacemanMenuHdle, menuXMLDescHdle, "TitleLabel");
if (str) {
int id = CreateLabelControl(racemanMenuHdle,menuXMLDescHdle,"title");
GfuiLabelSetText(racemanMenuHdle,id,str);
}
// Create New race, Configure race, Configure players and Back buttons. // Create New race, Configure race, Configure players and Back buttons.
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"newrace",NULL,ReStartNewRace); CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "StartRaceButton",
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"configurerace",NULL,ReConfigureMenu); NULL, ReStartNewRace);
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"configureplayers",NULL,rePlayerConfig); CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "ConfigureRaceButton",
NULL, ReConfigureMenu);
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"backtomain",ReInfo->_reMenuScreen,GfuiScreenActivate); CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "ConfigurePlayersButton",
NULL, reOnPlayerConfig);
CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "BackButton",
ReInfo->_reMenuScreen, GfuiScreenActivate);
// Create Load race button if we are in a Champ' like race type. // Create Load / Save race buttons.
if (GfParmGetEltNb(params, RM_SECT_TRACKS) > 1) { LoadRaceButtonId = CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "LoadRaceButton",
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"load",racemanMenuHdle,reFileSelectMenu); RacemanMenuHdle, reOnLoadRaceFromFile);
} SaveRaceButtonId = CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "SaveRaceButton",
RacemanMenuHdle, reOnSaveRaceToFile);
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle); // Close menu XML descriptor.
// Register keyboard shortcuts. GfParmReleaseHandle(menuXMLDescHdle);
GfuiMenuDefaultKeysAdd(racemanMenuHdle);
GfuiAddKey(racemanMenuHdle, GFUIK_ESCAPE, "Back to Main menu", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL); // Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(RacemanMenuHdle);
GfuiAddKey(RacemanMenuHdle, GFUIK_ESCAPE, "Back to Main menu",
ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
// Activate screen. // Activate screen.
GfuiScreenActivate(racemanMenuHdle); GfuiScreenActivate(RacemanMenuHdle);
return RM_ASYNC | RM_NEXT_STEP; return RM_ASYNC | RM_NEXT_STEP;
} }
static void static void
reStateManage(void * /* dummy */) reStateManage(void * /* dummy */)
{ {
ReStateManage(); ReStateManage();
} }
int int
ReNewTrackMenu(void) ReNewTrackMenu(void)
{ {
char buf[128]; char buf[128];
const char *str; void *params = ReInfo->params;
void *params = ReInfo->params; void *results = ReInfo->results;
void *results = ReInfo->results; int raceNumber;
int raceNumber; int xx;
int xx;
if (newTrackMenuHdle) { if (NewTrackMenuHdle) {
GfuiScreenRelease(newTrackMenuHdle); GfuiScreenRelease(NewTrackMenuHdle);
} }
// Create screen, load menu XML descriptor and create static controls. // Create screen, load menu XML descriptor and create static controls.
newTrackMenuHdle = GfuiScreenCreateEx(NULL, NewTrackMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL, NULL, (tfuiCallback)NULL,
NULL, (tfuiCallback)NULL, NULL, (tfuiCallback)NULL,
1); 1);
void *menuXMLDescHdle = LoadMenuXML("newtrackmenu.xml"); void *menuXMLDescHdle = LoadMenuXML("newtrackmenu.xml");
CreateStaticControls(menuXMLDescHdle,newTrackMenuHdle); CreateStaticControls(menuXMLDescHdle,NewTrackMenuHdle);
// Create background image from race params. // Create background image from race params.
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0); const char* pszBGImg = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
if (str) { if (pszBGImg) {
GfuiScreenAddBgImg(newTrackMenuHdle, str); GfuiScreenAddBgImg(NewTrackMenuHdle, pszBGImg);
} }
// Create variable title label from race params. // Create variable title label from race params.
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); int titleId = CreateLabelControl(NewTrackMenuHdle, menuXMLDescHdle, "titlelabel");
int titleId = CreateLabelControl(newTrackMenuHdle, menuXMLDescHdle, "titlelabel"); GfuiLabelSetText(NewTrackMenuHdle, titleId, ReInfo->_reName);
GfuiLabelSetText(newTrackMenuHdle, titleId, str);
// Calculate which race of the series this is // Calculate which race of the series this is
raceNumber = 1; raceNumber = 1;
for (xx = 1; xx < (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1); ++xx) for (xx = 1; xx < (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1); ++xx)
{ {
sprintf(buf, "%s/%d", RM_SECT_TRACKS, xx); sprintf(buf, "%s/%d", RM_SECT_TRACKS, xx);
if (!strcmp( GfParmGetStr(ReInfo->params, buf, RM_ATTR_NAME, "free"), "free") == 0) if (!strcmp( GfParmGetStr(ReInfo->params, buf, RM_ATTR_NAME, "free"), "free") == 0)
++raceNumber; ++raceNumber;
} }
// Create variable subtitle label from race params. // Create variable subtitle label from race params.
sprintf(buf, "Race Day #%d/%d on %s", sprintf(buf, "Race Day #%d/%d on %s",
raceNumber, raceNumber,
(int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) >= 0 ? (int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) >= 0 ?
(int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) : (int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) :
GfParmGetEltNb(params, RM_SECT_TRACKS), GfParmGetEltNb(params, RM_SECT_TRACKS),
ReInfo->track->name); ReInfo->track->name);
int subTitleId = CreateLabelControl(newTrackMenuHdle, menuXMLDescHdle, "subtitlelabel"); int subTitleId = CreateLabelControl(NewTrackMenuHdle, menuXMLDescHdle, "subtitlelabel");
GfuiLabelSetText(newTrackMenuHdle, subTitleId, buf); GfuiLabelSetText(NewTrackMenuHdle, subTitleId, buf);
// Create Start and Abandon buttons. // Create Start and Abandon buttons.
CreateButtonControl(newTrackMenuHdle, menuXMLDescHdle, "startbutton", NULL, reStateManage); CreateButtonControl(NewTrackMenuHdle, menuXMLDescHdle, "startbutton", NULL, reStateManage);
CreateButtonControl(newTrackMenuHdle, menuXMLDescHdle, "abandonbutton", ReInfo->_reMenuScreen, GfuiScreenActivate); CreateButtonControl(NewTrackMenuHdle, menuXMLDescHdle, "abandonbutton", ReInfo->_reMenuScreen, GfuiScreenActivate);
// Close menu XML descriptor. // Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle); GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts. // Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(newTrackMenuHdle); GfuiMenuDefaultKeysAdd(NewTrackMenuHdle);
GfuiAddKey(newTrackMenuHdle, GFUIK_RETURN, "Start Event", NULL, reStateManage, NULL); GfuiAddKey(NewTrackMenuHdle, GFUIK_RETURN, "Start Event", NULL, reStateManage, NULL);
GfuiAddKey(newTrackMenuHdle, GFUIK_ESCAPE, "Abandon", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL); GfuiAddKey(NewTrackMenuHdle, GFUIK_ESCAPE, "Abandon", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
// Activate screen. // Activate screen.
GfuiScreenActivate(newTrackMenuHdle); GfuiScreenActivate(NewTrackMenuHdle);
return RM_ASYNC | RM_NEXT_STEP; return RM_ASYNC | RM_NEXT_STEP;
} }

190
src/libs/racescreens/fileselect.cpp
View file

@ -2,33 +2,32 @@
file : fileselect.cpp file : fileselect.cpp
created : Sun Feb 16 13:09:23 CET 2003 created : Sun Feb 16 13:09:23 CET 2003
copyright : (C) 2003 by Eric Espi<EFBFBD> copyright : (C) 2003 by Eric Espie
email : eric.espie@torcs.org email : eric.espie@torcs.org
version : $Id: fileselect.cpp,v 1.2 2003/06/24 21:02:24 torcs Exp $ version : $Id: fileselect.cpp,v 1.2 2003/06/24 21:02:24 torcs $
***************************************************************************/ ***************************************************************************/
/*************************************************************************** /***************************************************************************
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
***************************************************************************/ ***************************************************************************/
/** @file /** @file
Files manipulation screens. Files open/save menu screens.
@ingroup racemantools @ingroup racemantools
@author <a href=mailto:eric.espie@torcs.org>Eric Espie</a> @author <a href=mailto:eric.espie@torcs.org>Eric Espie</a>
@version $Id: fileselect.cpp,v 1.2 2003/06/24 21:02:24 torcs Exp $ @version $Id: fileselect.cpp,v 1.2 2003/06/24 21:02:24 torcs Exp $
*/ */
#include <stdlib.h> #include <cstdlib>
#include <stdio.h> #include <cstdio>
#include <cstring> #include <cstring>
#include <sys/stat.h> //#include <sys/stat.h>
#ifdef WIN32 #ifdef WIN32
#include <windows.h> #include <windows.h>
#endif #endif
@ -39,97 +38,132 @@
#include "racescreens.h" #include "racescreens.h"
static void *ScrHandle = NULL; static void *ScrHandle = NULL;
static int FileScrollListId;
static int FilesScrollListId;
static int FileNameEditId;
static int LoadButtonId;
static int SaveButtonId;
static tRmFileSelect *RmFs; static tRmFileSelect *RmFs;
static tFList *FileList = NULL; static tFList *FileList = NULL;
static tFList *FileSelected; static tFList *FileSelected;
static void static void
rmActivate(void * /* dummy */ ) rmOnActivate(void * /* dummy */ )
{
// Fill-in the Scroll List with the names of the files in the specified folder.
GfuiScrollListClear(ScrHandle, FilesScrollListId);
FileList = GfDirGetList(RmFs->path);
if (FileList)
{
tFList *fileCur;
FileSelected = FileList;
fileCur = FileList;
do {
fileCur = fileCur->next;
GfuiScrollListInsertElement(ScrHandle, FilesScrollListId, fileCur->name, 1000, (void*)fileCur);
} while (fileCur != FileList);
}
// Clear the file name edit box.
GfuiEditboxSetString(ScrHandle, FileNameEditId, "");
// Show/Hide Load/Save buttons according to the file selection mode.
GfuiVisibilitySet(ScrHandle, LoadButtonId,
RmFs->mode == RmFSModeLoad ? GFUI_VISIBLE : GFUI_INVISIBLE);
GfuiVisibilitySet(ScrHandle, SaveButtonId,
RmFs->mode == RmFSModeSave ? GFUI_VISIBLE : GFUI_INVISIBLE);
// Inhibit file name control editbox if only loading.
GfuiEnable(ScrHandle, FileNameEditId,
RmFs->mode == RmFSModeLoad ? GFUI_DISABLE : GFUI_ENABLE);
}
static void
rmOnClickOnFile(void * /*dummy*/)
{
GfuiScrollListGetSelectedElement(ScrHandle, FilesScrollListId, (void**)&FileSelected);
GfuiEditboxSetString(ScrHandle, FileNameEditId, FileSelected->name);
}
static void
rmOnChangeFileName(void * /* dummy */)
{ {
} }
static void static void
rmClickOnFile(void * /*dummy*/) rmOnDeactivate(void * /* dummy */ )
{ {
GfuiScrollListGetSelectedElement(ScrHandle, FileScrollListId, (void**)&FileSelected); // Force current edit to loose focus (if one has it) and update associated variable.
GfuiUnSelectCurrent();
// Free allocated memory for the folder file list.
if (FileList) {
GfDirFreeList(FileList, NULL);
FileList = NULL;
}
// Fire the return screen
GfuiScreenActivate(RmFs->prevScreen);
} }
static void static void
rmSelect(void * /* dummy */ ) rmOnSelect(void * /* dummy */ )
{ {
if (FileList) { char* pszFileName = GfuiEditboxGetString(ScrHandle, FileNameEditId);
RmFs->select(FileSelected->name);
GfDirFreeList(FileList, NULL);
FileList = NULL;
} else {
RmFs->select(NULL);
}
}
static void if (pszFileName && strlen(pszFileName) > 0)
rmDeactivate(void * /* dummy */ ) {
{ RmFs->select(pszFileName);
if (FileList) { rmOnDeactivate(0);
GfDirFreeList(FileList, NULL); }
FileList = NULL;
}
GfuiScreenActivate(RmFs->prevScreen);
} }
/** File selection /** File selection
@param vs Pointer on tRmFileSelect structure (cast to void) @param pFileSelect Pointer on tRmFileSelect structure (cast to void)
@return none @return none
*/ */
void void*
RmFileSelect(void *vs) RmFileSelect(void *pFileSelect)
{ {
tFList *FileCur; RmFs = (tRmFileSelect*)pFileSelect;
RmFs = (tRmFileSelect*)vs; if (ScrHandle) {
return ScrHandle;
}
if (ScrHandle) { // Create screen, load menu XML descriptor and create static controls.
GfuiScreenRelease(ScrHandle); ScrHandle = GfuiScreenCreateEx(NULL, NULL, rmOnActivate, NULL, NULL, 1);
}
// Create screen, load menu XML descriptor and create static controls. void *menuXMLDescHdle = LoadMenuXML("fileselectmenu.xml");
ScrHandle = GfuiScreenCreateEx(NULL, NULL, rmActivate, NULL, NULL, 1);
void *menuXMLDescHdle = LoadMenuXML("fileselectmenu.xml"); CreateStaticControls(menuXMLDescHdle, ScrHandle);
CreateStaticControls(menuXMLDescHdle, ScrHandle); // Create variable title label.
const int titleId = CreateLabelControl(ScrHandle, menuXMLDescHdle, "TitleLabel");
GfuiLabelSetText(ScrHandle, titleId, RmFs->title);
// Create the Scroll List containing the File list
FilesScrollListId = CreateScrollListControl(ScrHandle, menuXMLDescHdle, "FilesScrollList",
NULL, rmOnClickOnFile);
// Create variable title label. // Create the filename edit box
int titleId = CreateLabelControl(ScrHandle, menuXMLDescHdle, "titlelabel"); FileNameEditId = CreateEditControl(ScrHandle, menuXMLDescHdle, "SelectedFileNameEdit",
GfuiLabelSetText(ScrHandle, titleId, RmFs->title); NULL, NULL, rmOnChangeFileName);
/* Create and fill-in the Scroll List containing the File list */
FileScrollListId = CreateScrollListControl(ScrHandle, menuXMLDescHdle, "filescrolllist",
NULL, rmClickOnFile);
FileList = GfDirGetList(RmFs->path); // Create Load/Save and Cancel buttons.
if (FileList == NULL) { LoadButtonId = CreateButtonControl(ScrHandle, menuXMLDescHdle, "LoadButton", NULL, rmOnSelect);
GfuiScreenActivate(RmFs->prevScreen); SaveButtonId = CreateButtonControl(ScrHandle, menuXMLDescHdle, "SaveButton", NULL, rmOnSelect);
return; CreateButtonControl(ScrHandle, menuXMLDescHdle, "CancelButton", NULL, rmOnDeactivate);
}
FileSelected = FileList;
FileCur = FileList;
do {
FileCur = FileCur->next;
GfuiScrollListInsertElement(ScrHandle, FileScrollListId, FileCur->name, 1000, (void*)FileCur);
} while (FileCur != FileList);
// Create Back and Reset buttons. // Close menu XML descriptor.
CreateButtonControl(ScrHandle, menuXMLDescHdle, "selectbutton", NULL, rmSelect); GfParmReleaseHandle(menuXMLDescHdle);
CreateButtonControl(ScrHandle, menuXMLDescHdle, "cancelbutton", NULL, rmDeactivate);
// Register keyboard shortcuts.
GfuiAddKey(ScrHandle, GFUIK_ESCAPE, "Cancel", NULL, rmOnDeactivate, NULL);
GfuiMenuDefaultKeysAdd(ScrHandle);
// Close menu XML descriptor. return ScrHandle;
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiAddKey(ScrHandle, GFUIK_ESCAPE, "Cancel", NULL, rmDeactivate, NULL);
GfuiMenuDefaultKeysAdd(ScrHandle);
GfuiScreenActivate(ScrHandle);
} }

7
src/libs/racescreens/racescreens.h
View file

@ -65,7 +65,9 @@ typedef struct RmRaceParam
#define RM_CONF_DISP_MODE 0x00000002 #define RM_CONF_DISP_MODE 0x00000002
} tRmRaceParam; } tRmRaceParam;
typedef void (*tfSelectFile) (char *); typedef void (*tfSelectFile) (const char *);
enum RmFileSelectMode { RmFSModeLoad, RmFSModeSave };
typedef struct RmFileSelect typedef struct RmFileSelect
{ {
@ -73,6 +75,7 @@ typedef struct RmFileSelect
const char *path; const char *path;
void *prevScreen; void *prevScreen;
tfSelectFile select; tfSelectFile select;
RmFileSelectMode mode;
} tRmFileSelect; } tRmFileSelect;
RACESCREENS_API void RmTrackSelect(void * /* vs */); RACESCREENS_API void RmTrackSelect(void * /* vs */);
@ -117,7 +120,7 @@ RACESCREENS_API void RmRaceParamMenu(void *vrp);
RACESCREENS_API void RmShowStandings(void *prevHdle, tRmInfo *info); RACESCREENS_API void RmShowStandings(void *prevHdle, tRmInfo *info);
RACESCREENS_API void RmFileSelect(void *vs); RACESCREENS_API void* RmFileSelect(void *vs);
RACESCREENS_API int RmGetFeaturesList( void* param ); RACESCREENS_API int RmGetFeaturesList( void* param );