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 tModList *reEventModList = 0;
tModList *ReRaceModList = 0;
tFList *ReRacemanList;
static char buf[1024];
static char path[1024];
@ -167,14 +172,17 @@ ReStartNewRace(void * /* dummy */)
/* Launch a race manager */
static void reSelectRaceman(void *params)
static void reSelectRaceman(void *pRaceman)
{
char *s, *e, *m;
GfTrace("Selecting %s race type\n", GfParmGetName(params));
void* params = ((tFList*)pRaceman)->userData;
ReInfo->params = params;
ReInfo->mainParams = params;
ReInfo->_reName = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, "");
// Set new file name.
FREEZ(ReInfo->_reFilename);
s = GfParmGetFileName(params);
@ -183,11 +191,12 @@ static void reSelectRaceman(void *params)
}
e = strstr(s, PARAMEXT);
//This line doesn't compile with MSVC
//ReInfo->_reFilename = strndup(s, e-s+1);
ReInfo->_reFilename = strdup(s);
ReInfo->_reFilename = strdup(s); // "strndup(s, e-s+1)" doesn't compile with MSVC.
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);
}
@ -210,6 +219,24 @@ reRegisterRaceman(tFList *racemanCur)
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 */
static void
reSortRacemanList(tFList **racemanList)
@ -249,47 +276,33 @@ reSortRacemanList(tFList **racemanList)
/* Load race managers selection menu */
void ReAddRacemanListButton(void *menuHandle, void *menuXMLDescHandle)
{
tFList *racemanList;
tFList *racemanCur;
racemanList = GfDirGetListFiltered("config/raceman", "", ".xml");
if (!racemanList) {
// Create racemans list from <user settings>/config/raceman/*.xml folder
ReRacemanList = GfDirGetListFiltered("config/raceman", "", PARAMEXT);
if (!ReRacemanList) {
GfError("No race manager available\n");
return;
}
racemanCur = racemanList;
// Complete the raceman list : load the race configuration for each raceman.
racemanCur = ReRacemanList;
do {
reRegisterRaceman(racemanCur);
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, ...
racemanCur = racemanList;
racemanCur = ReRacemanList;
do {
CreateButtonControl(menuHandle,menuXMLDescHandle,racemanCur->dispName,racemanCur->userData,reSelectRaceman);
/*
GfuiMenuButtonCreate(menuHandle,
racemanCur->dispName,
GfParmGetStr(racemanCur->userData, RM_SECT_HEADER, RM_ATTR_DESCR, ""),
racemanCur->userData,
reSelectRaceman);
*/
CreateButtonControl(menuHandle, menuXMLDescHandle, racemanCur->dispName,
racemanCur, reSelectRaceman);
racemanCur = racemanCur->next;
} while (racemanCur != racemanList);
// 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);
} while (racemanCur != ReRacemanList);
}

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

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

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

@ -2,9 +2,9 @@
file : racemanmenu.cpp
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
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
@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>
@ -41,9 +41,16 @@
#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 tRmDriverSelect ds;
static tRmRaceParam rp;
@ -55,13 +62,13 @@ static void reConfigRunState(void);
static void
reConfigBack(void)
{
void *params = ReInfo->params;
void* params = ReInfo->params;
/* Go back one step in the conf */
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL,
GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1) - 2);
/* Go back one step in the conf */
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL,
GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1) - 2);
reConfigRunState();
reConfigRunState();
}
@ -72,19 +79,18 @@ static void *configHookHandle = 0;
static void
configHookActivate(void * /* dummy */)
{
reConfigRunState();
reConfigRunState();
}
static void *
reConfigHookInit(void)
{
if (configHookHandle) {
if (configHookHandle)
return configHookHandle;
configHookHandle = GfuiHookCreate(0, configHookActivate);
return configHookHandle;
}
configHookHandle = GfuiHookCreate(0, configHookActivate);
return configHookHandle;
}
/***************************************************************/
@ -95,182 +101,320 @@ static void *ConfigBackHookHandle = 0;
static void
ConfigBackHookActivate(void * /* dummy */)
{
reConfigBack();
reConfigBack();
}
static void *
reConfigBackHookInit(void)
{
if (ConfigBackHookHandle) {
if (ConfigBackHookHandle)
return ConfigBackHookHandle;
ConfigBackHookHandle = GfuiHookCreate(0, ConfigBackHookActivate);
return ConfigBackHookHandle;
}
ConfigBackHookHandle = GfuiHookCreate(0, ConfigBackHookActivate);
return ConfigBackHookHandle;
}
static void
reConfigRunState(void)
{
char path[256];
int i;
int curConf;
const char *conf;
int numOpt;
const char *opt;
void *params = ReInfo->params;
char path[256];
int i;
int curConf;
const char *conf;
int numOpt;
const char *opt;
void *params = ReInfo->params;
curConf = (int)GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
if (curConf > GfParmGetEltNb(params, RM_SECT_CONF)) {
GfOut("End of configuration\n");
GfParmWriteFile(NULL, ReInfo->params, ReInfo->_reName);
goto menuback;
}
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();
curConf = (int)GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
if (curConf > GfParmGetEltNb(params, RM_SECT_CONF)) {
GfLogInfo("%s configuration finished.\n", ReInfo->_reName);
GfParmWriteFile(NULL, ReInfo->params, ReInfo->_reName);
GfuiScreenActivate(RacemanMenuHdle); /* Back to the race menu */
return;
}
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();
sprintf(path, "%s/%d", RM_SECT_CONF, curConf);
conf = GfParmGetStr(params, path, RM_ATTR_TYPE, 0);
if (!conf) {
GfLogError("No %s here (%s) !\n", RM_ATTR_TYPE, path);
GfuiScreenActivate(RacemanMenuHdle); /* Back to the race menu */
return;
}
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;
GfLogInfo("%s configuration now in '%s' stage.\n", ReInfo->_reName, 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;
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++;
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, curConf);
return;
/* Back to the race menu */
menuback:
GfuiScreenActivate(racemanMenuHdle);
return;
curConf++;
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, curConf);
}
void ReSetRacemanMenuHandle( void * handle)
void ReSetRacemanMenuHandle(void * handle)
{
racemanMenuHdle = handle;
RacemanMenuHdle = handle;
}
void
ReConfigureMenu(void * /* dummy */)
{
void *params = ReInfo->params;
void *params = ReInfo->params;
/* Reset configuration automaton */
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
reConfigRunState();
/* Reset configuration automaton */
GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
reConfigRunState();
}
static void
reSelectResultsFile(char *filename)
reLoadRaceFromResultsFile(const char *filename)
{
char buf[512];
char buf[256];
sprintf(buf, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename);
GfLogInfo("Loading saved race from %s ...\n", buf);
ReInfo->mainResults = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
ReInfo->results = ReInfo->mainResults;
ReInfo->_reRaceName = ReInfo->_reName;
GfParmRemoveVariable (ReInfo->params, "/", "humanInGroup");
GfParmSetVariable (ReInfo->params, "/", "humanInGroup", ReHumanInGroup() ? 1 : 0);
RmShowStandings(ReInfo->_reGameScreen, ReInfo);
sprintf(buf, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename);
GfLogInfo("Loading saved race from %s ...\n", buf);
// Update race data.
ReInfo->mainResults = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
ReInfo->results = ReInfo->mainResults;
ReInfo->_reRaceName = ReInfo->_reName;
GfParmRemoveVariable (ReInfo->params, "/", "humanInGroup");
GfParmSetVariable (ReInfo->params, "/", "humanInGroup", ReHumanInGroup() ? 1 : 0);
// Fire standings screen.
RmShowStandings(ReInfo->_reGameScreen, ReInfo);
}
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;
void *params = ReInfo->params;
// Replace the main race file by the selected one.
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;
fs.select = reSelectResultsFile;
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0);
if (str) {
fs.title = str;
}
sprintf(buf, "%sresults/%s", GetLocalDir(), ReInfo->_reFilename);
fs.path = buf;
RmFileSelect((void*)&fs);
// Update raceman info (the params pointer changed).
char pszFileName[64];
sprintf(pszFileName, "%s%s", ReInfo->_reFilename, PARAMEXT);
ReUpdateRaceman(pszFileName, ReInfo->params);
}
static void
rePlayerConfig(void * /* dummy */)
reSaveRaceToConfigFile(const char *filename)
{
/* 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));
// Note: No need to write the main file here, already done at the end of race configuration.
char pszMainFilePathName[256];
sprintf(pszMainFilePathName, "%sconfig/raceman/%s%s",
GetLocalDir(), ReInfo->_reFilename, PARAMEXT);
// 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
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(str,"Online Race")==0)
{
if (strcmp(ReInfo->_reName,"Online Race")==0)
{
if (GetNetwork())
{
if (GetNetwork()->IsConnected())
@ -293,125 +437,126 @@ ReRacemanMenu(void)
return RM_ASYNC | RM_NEXT_STEP;
}
}
}
if (racemanMenuHdle) {
GfuiScreenRelease(racemanMenuHdle);
}
if (RacemanMenuHdle)
GfuiScreenRelease(RacemanMenuHdle);
// Create screen, load menu XML descriptor and create static controls.
racemanMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL,
// Create screen, load menu XML descriptor and create static controls.
RacemanMenuHdle = GfuiScreenCreateEx(NULL,
NULL, reOnActivate,
NULL, (tfuiCallback)NULL,
1);
void *menuXMLDescHdle = LoadMenuXML("racechoicemenu.xml");
CreateStaticControls(menuXMLDescHdle,racemanMenuHdle);
void *menuXMLDescHdle = LoadMenuXML("racemanmenu.xml");
CreateStaticControls(menuXMLDescHdle, RacemanMenuHdle);
// Create variable title label.
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0);
if (str) {
int id = CreateLabelControl(racemanMenuHdle,menuXMLDescHdle,"title");
GfuiLabelSetText(racemanMenuHdle,id,str);
}
// Create variable title label.
TitleLabelId = CreateLabelControl(RacemanMenuHdle, menuXMLDescHdle, "TitleLabel");
// Create New race, Configure race, Configure players and Back buttons.
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"newrace",NULL,ReStartNewRace);
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"configurerace",NULL,ReConfigureMenu);
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"configureplayers",NULL,rePlayerConfig);
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"backtomain",ReInfo->_reMenuScreen,GfuiScreenActivate);
// Create New race, Configure race, Configure players and Back buttons.
CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "StartRaceButton",
NULL, ReStartNewRace);
CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "ConfigureRaceButton",
NULL, ReConfigureMenu);
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.
if (GfParmGetEltNb(params, RM_SECT_TRACKS) > 1) {
CreateButtonControl(racemanMenuHdle,menuXMLDescHdle,"load",racemanMenuHdle,reFileSelectMenu);
}
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(racemanMenuHdle);
GfuiAddKey(racemanMenuHdle, GFUIK_ESCAPE, "Back to Main menu", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
// Create Load / Save race buttons.
LoadRaceButtonId = CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "LoadRaceButton",
RacemanMenuHdle, reOnLoadRaceFromFile);
SaveRaceButtonId = CreateButtonControl(RacemanMenuHdle, menuXMLDescHdle, "SaveRaceButton",
RacemanMenuHdle, reOnSaveRaceToFile);
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(RacemanMenuHdle);
GfuiAddKey(RacemanMenuHdle, GFUIK_ESCAPE, "Back to Main menu",
ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
// Activate screen.
GfuiScreenActivate(racemanMenuHdle);
// Activate screen.
GfuiScreenActivate(RacemanMenuHdle);
return RM_ASYNC | RM_NEXT_STEP;
return RM_ASYNC | RM_NEXT_STEP;
}
static void
reStateManage(void * /* dummy */)
{
ReStateManage();
ReStateManage();
}
int
ReNewTrackMenu(void)
{
char buf[128];
char buf[128];
const char *str;
void *params = ReInfo->params;
void *results = ReInfo->results;
int raceNumber;
int xx;
void *params = ReInfo->params;
void *results = ReInfo->results;
int raceNumber;
int xx;
if (newTrackMenuHdle) {
GfuiScreenRelease(newTrackMenuHdle);
}
if (NewTrackMenuHdle) {
GfuiScreenRelease(NewTrackMenuHdle);
}
// Create screen, load menu XML descriptor and create static controls.
newTrackMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL,
NULL, (tfuiCallback)NULL,
1);
void *menuXMLDescHdle = LoadMenuXML("newtrackmenu.xml");
CreateStaticControls(menuXMLDescHdle,newTrackMenuHdle);
// Create screen, load menu XML descriptor and create static controls.
NewTrackMenuHdle = GfuiScreenCreateEx(NULL,
NULL, (tfuiCallback)NULL,
NULL, (tfuiCallback)NULL,
1);
void *menuXMLDescHdle = LoadMenuXML("newtrackmenu.xml");
CreateStaticControls(menuXMLDescHdle,NewTrackMenuHdle);
// Create background image from race params.
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
if (str) {
GfuiScreenAddBgImg(newTrackMenuHdle, str);
}
// Create background image from race params.
const char* pszBGImg = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
if (pszBGImg) {
GfuiScreenAddBgImg(NewTrackMenuHdle, pszBGImg);
}
// Create variable title label from race params.
str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, "");
int titleId = CreateLabelControl(newTrackMenuHdle, menuXMLDescHdle, "titlelabel");
GfuiLabelSetText(newTrackMenuHdle, titleId, str);
// Create variable title label from race params.
int titleId = CreateLabelControl(NewTrackMenuHdle, menuXMLDescHdle, "titlelabel");
GfuiLabelSetText(NewTrackMenuHdle, titleId, ReInfo->_reName);
// Calculate which race of the series this is
raceNumber = 1;
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);
if (!strcmp( GfParmGetStr(ReInfo->params, buf, RM_ATTR_NAME, "free"), "free") == 0)
++raceNumber;
}
// Calculate which race of the series this is
raceNumber = 1;
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);
if (!strcmp( GfParmGetStr(ReInfo->params, buf, RM_ATTR_NAME, "free"), "free") == 0)
++raceNumber;
}
// Create variable subtitle label from race params.
sprintf(buf, "Race Day #%d/%d on %s",
raceNumber,
(int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) >= 0 ?
(int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) :
GfParmGetEltNb(params, RM_SECT_TRACKS),
ReInfo->track->name);
int subTitleId = CreateLabelControl(newTrackMenuHdle, menuXMLDescHdle, "subtitlelabel");
GfuiLabelSetText(newTrackMenuHdle, subTitleId, buf);
// Create variable subtitle label from race params.
sprintf(buf, "Race Day #%d/%d on %s",
raceNumber,
(int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) >= 0 ?
(int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) :
GfParmGetEltNb(params, RM_SECT_TRACKS),
ReInfo->track->name);
int subTitleId = CreateLabelControl(NewTrackMenuHdle, menuXMLDescHdle, "subtitlelabel");
GfuiLabelSetText(NewTrackMenuHdle, subTitleId, buf);
// Create Start and Abandon buttons.
CreateButtonControl(newTrackMenuHdle, menuXMLDescHdle, "startbutton", NULL, reStateManage);
CreateButtonControl(newTrackMenuHdle, menuXMLDescHdle, "abandonbutton", ReInfo->_reMenuScreen, GfuiScreenActivate);
// Create Start and Abandon buttons.
CreateButtonControl(NewTrackMenuHdle, menuXMLDescHdle, "startbutton", NULL, reStateManage);
CreateButtonControl(NewTrackMenuHdle, menuXMLDescHdle, "abandonbutton", ReInfo->_reMenuScreen, GfuiScreenActivate);
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(newTrackMenuHdle);
GfuiAddKey(newTrackMenuHdle, GFUIK_RETURN, "Start Event", NULL, reStateManage, NULL);
GfuiAddKey(newTrackMenuHdle, GFUIK_ESCAPE, "Abandon", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiMenuDefaultKeysAdd(NewTrackMenuHdle);
GfuiAddKey(NewTrackMenuHdle, GFUIK_RETURN, "Start Event", NULL, reStateManage, NULL);
GfuiAddKey(NewTrackMenuHdle, GFUIK_ESCAPE, "Abandon", ReInfo->_reMenuScreen, GfuiScreenActivate, NULL);
// Activate screen.
GfuiScreenActivate(newTrackMenuHdle);
// Activate screen.
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
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
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 *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
/** @file
Files manipulation screens.
@ingroup racemantools
@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 $
Files open/save menu screens.
@ingroup racemantools
@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 $
*/
#include <stdlib.h>
#include <stdio.h>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <sys/stat.h>
//#include <sys/stat.h>
#ifdef WIN32
#include <windows.h>
#endif
@ -39,97 +38,132 @@
#include "racescreens.h"
static void *ScrHandle = NULL;
static int FileScrollListId;
static int FilesScrollListId;
static int FileNameEditId;
static int LoadButtonId;
static int SaveButtonId;
static tRmFileSelect *RmFs;
static tFList *FileList = NULL;
static tFList *FileSelected;
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
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
rmSelect(void * /* dummy */ )
rmOnSelect(void * /* dummy */ )
{
if (FileList) {
RmFs->select(FileSelected->name);
GfDirFreeList(FileList, NULL);
FileList = NULL;
} else {
RmFs->select(NULL);
}
}
char* pszFileName = GfuiEditboxGetString(ScrHandle, FileNameEditId);
static void
rmDeactivate(void * /* dummy */ )
{
if (FileList) {
GfDirFreeList(FileList, NULL);
FileList = NULL;
}
GfuiScreenActivate(RmFs->prevScreen);
if (pszFileName && strlen(pszFileName) > 0)
{
RmFs->select(pszFileName);
rmOnDeactivate(0);
}
}
/** File selection
@param vs Pointer on tRmFileSelect structure (cast to void)
@return none
@param pFileSelect Pointer on tRmFileSelect structure (cast to void)
@return none
*/
void
RmFileSelect(void *vs)
void*
RmFileSelect(void *pFileSelect)
{
tFList *FileCur;
RmFs = (tRmFileSelect*)pFileSelect;
RmFs = (tRmFileSelect*)vs;
if (ScrHandle) {
return ScrHandle;
}
if (ScrHandle) {
GfuiScreenRelease(ScrHandle);
}
// Create screen, load menu XML descriptor and create static controls.
ScrHandle = GfuiScreenCreateEx(NULL, NULL, rmOnActivate, NULL, NULL, 1);
// Create screen, load menu XML descriptor and create static controls.
ScrHandle = GfuiScreenCreateEx(NULL, NULL, rmActivate, NULL, NULL, 1);
void *menuXMLDescHdle = LoadMenuXML("fileselectmenu.xml");
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.
int titleId = CreateLabelControl(ScrHandle, menuXMLDescHdle, "titlelabel");
GfuiLabelSetText(ScrHandle, titleId, RmFs->title);
/* Create and fill-in the Scroll List containing the File list */
FileScrollListId = CreateScrollListControl(ScrHandle, menuXMLDescHdle, "filescrolllist",
NULL, rmClickOnFile);
// Create the filename edit box
FileNameEditId = CreateEditControl(ScrHandle, menuXMLDescHdle, "SelectedFileNameEdit",
NULL, NULL, rmOnChangeFileName);
FileList = GfDirGetList(RmFs->path);
if (FileList == NULL) {
GfuiScreenActivate(RmFs->prevScreen);
return;
}
FileSelected = FileList;
FileCur = FileList;
do {
FileCur = FileCur->next;
GfuiScrollListInsertElement(ScrHandle, FileScrollListId, FileCur->name, 1000, (void*)FileCur);
} while (FileCur != FileList);
// Create Load/Save and Cancel buttons.
LoadButtonId = CreateButtonControl(ScrHandle, menuXMLDescHdle, "LoadButton", NULL, rmOnSelect);
SaveButtonId = CreateButtonControl(ScrHandle, menuXMLDescHdle, "SaveButton", NULL, rmOnSelect);
CreateButtonControl(ScrHandle, menuXMLDescHdle, "CancelButton", NULL, rmOnDeactivate);
// Create Back and Reset buttons.
CreateButtonControl(ScrHandle, menuXMLDescHdle, "selectbutton", NULL, rmSelect);
CreateButtonControl(ScrHandle, menuXMLDescHdle, "cancelbutton", NULL, rmDeactivate);
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiAddKey(ScrHandle, GFUIK_ESCAPE, "Cancel", NULL, rmOnDeactivate, NULL);
GfuiMenuDefaultKeysAdd(ScrHandle);
// Close menu XML descriptor.
GfParmReleaseHandle(menuXMLDescHdle);
// Register keyboard shortcuts.
GfuiAddKey(ScrHandle, GFUIK_ESCAPE, "Cancel", NULL, rmDeactivate, NULL);
GfuiMenuDefaultKeysAdd(ScrHandle);
GfuiScreenActivate(ScrHandle);
return ScrHandle;
}

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

@ -65,7 +65,9 @@ typedef struct RmRaceParam
#define RM_CONF_DISP_MODE 0x00000002
} tRmRaceParam;
typedef void (*tfSelectFile) (char *);
typedef void (*tfSelectFile) (const char *);
enum RmFileSelectMode { RmFSModeLoad, RmFSModeSave };
typedef struct RmFileSelect
{
@ -73,6 +75,7 @@ typedef struct RmFileSelect
const char *path;
void *prevScreen;
tfSelectFile select;
RmFileSelectMode mode;
} tRmFileSelect;
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 RmFileSelect(void *vs);
RACESCREENS_API void* RmFileSelect(void *vs);
RACESCREENS_API int RmGetFeaturesList( void* param );