void WorkspaceWork::AddFile(ADDFILE af)
{
String active = GetActivePackage();
if(active.IsEmpty()) return;
FileSel *fs = &OutputFs();
RealizeDirectory(GetLocalDir());
switch(af)
{
case PACKAGE_FILE: fs = &BasedSourceFs(); fs->BaseDir(GetFileFolder(PackagePathA(active))); break;
case ANY_FILE: fs = &AnySourceFs(); break;
case OUTPUT_FILE: fs->ActiveDir(GetOutputDir()); break;
case CONFIG_FILE: fs->ActiveDir(GetConfigDir()); break;
case HOME_FILE: fs->ActiveDir(GetHomeDirectory()); break;
case LOCAL_FILE: fs->ActiveDir(GetLocalDir()); break;
default: ; // GCC warns otherwise
}
if(!fs->ExecuteOpen("Add files to package..")) return;
int fci = filelist.GetCursor();
int cs = filelist.GetSbPos();
int ci = fci >= 0 && fci < fileindex.GetCount() ? fileindex[fci] : -1;
for(int i = 0; i < fs->GetCount(); i++) {
Package::File& f = ci >= 0 ? actual.file.Insert(ci++) : actual.file.Add();
f = (*fs)[i];
f.readonly = fs->GetReadOnly();
}
SaveLoadPackage(false);
filelist.SetSbPos(cs);
filelist.SetCursor(fci >= 0 ? fci : filelist.GetCount() - 1);
FileSelected();
}
// 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;
}
/*
* Function
*
*
* Description
* search under drivers/human/tracks/<trackname>/car-<model>-<index>.xml
* drivers/human/car-<model>-<index>.xml
* drivers/human/tracks/<trackname>/car-<model>.xml
* drivers/human/car-<model>.xml
*
* Parameters
*
*
* Return
*
*
* Remarks
*
*/
static void initTrack(int index, tTrack* track, void *carHandle, void **carParmHandle, tSituation *s)
{
const char *carname;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
char sstring[BUFSIZE];
tdble fuel;
int idx = index - 1;
curTrack = track;
snprintf(sstring, BUFSIZE, "Robots/index/%d", index);
snprintf(buf, BUFSIZE, "%sdrivers/human/human.xml", GetLocalDir());
void *DrvInfo = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
carname = "";
if (DrvInfo != NULL) {
carname = GfParmGetStr(DrvInfo, sstring, "car name", "");
}
*carParmHandle = NULL;
// If session type is "race" and we have a race setup use it
if (s->_raceType == RM_TYPE_RACE) {
*carParmHandle = RtParmReadSetup(RACE, "human", index, track->internalname, carname);
}
// If session type is "qualifying" and we have a qualifying setup use it, use qualifying setup as
// fallback if not race setup is available
if (s->_raceType == RM_TYPE_QUALIF || (*carParmHandle == NULL && s->_raceType == RM_TYPE_RACE)) {
*carParmHandle = RtParmReadSetup(QUALIFYING, "human", index, track->internalname, carname);
}
// If we have not yet loaded a setup we have not found a fitting one or want to use the practice setup,
// so try to load this
if (*carParmHandle == NULL) {
*carParmHandle = RtParmReadSetup(PRACTICE, "human", index, track->internalname, carname);
}
// Absolute fallback, nothing found
if (*carParmHandle == NULL) {
snprintf(sstring, BUFSIZE, "%sdrivers/human/car.xml", GetLocalDir ());
*carParmHandle = GfParmReadFile(sstring, GFPARM_RMODE_REREAD);
}
if (curTrack->pits.type != TR_PIT_NONE) {
snprintf(sstring, BUFSIZE, "%s/%s/%d", HM_SECT_PREF, HM_LIST_DRV, index);
HCtx[idx]->NbPitStopProg = (int)GfParmGetNum(PrefHdle, sstring, HM_ATT_NBPITS, (char*)NULL, 0);
GfOut("Player: index %d , Pits stops %d\n", index, HCtx[idx]->NbPitStopProg);
} else {
HCtx[idx]->NbPitStopProg = 0;
}
fuel = 0.0008 * curTrack->length * (s->_totLaps + 1) / (1.0 + ((tdble)HCtx[idx]->NbPitStopProg)) + 20.0;
if (*carParmHandle) {
GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, (char*)NULL, fuel);
}
Vtarget = curTrack->pits.speedLimit;
if (DrvInfo != NULL) {
GfParmReleaseHandle(DrvInfo);
}
}
//==========================================================================*
// Get filehandle for robot's xml-file
//--------------------------------------------------------------------------*
void* GetFileHandle(const char* RobotName)
{
void* RobotSettings = NULL;
strncpy(BufName, RobotName, BUFSIZE); // Save robot's name
snprintf(BufPathDirRel, BUFSIZE, // Robot's directory
"drivers/%s",RobotName); // relative to installation
snprintf(BufPathXMLRel, BUFSIZE, // Robot's xml-filename
"drivers/%s/%s.xml",RobotName,RobotName);// relative to installation
// Test local installation path
snprintf(BufPathXML, BUFSIZE, "%s%s",
GetLocalDir(), RobPathXMLRel);
snprintf(BufPathDir, BUFSIZE, "%s%s",
GetLocalDir(), RobPathDirRel);
RobotSettings = GfParmReadFile
(RobPathXML, GFPARM_RMODE_STD );
if (!RobotSettings)
{
// If not found, use global installation path
snprintf(BufPathXML, BUFSIZE, "%s%s",
GetDataDir(), RobPathXMLRel);
snprintf(BufPathDir, BUFSIZE, "%s%s",
GetDataDir(), RobPathDirRel);
RobotSettings = GfParmReadFile
(RobPathXML, GFPARM_RMODE_STD );
}
return RobotSettings;
}
/** Add an image background to a screen.
@ingroup gui
@param scr Screen
@param filename file name of the bg image
@return None.
*/
void
GfuiScreenAddBgImg(void *scr, const char *filename)
{
tGfuiScreen *screen = (tGfuiScreen*)scr;
void *handle;
float screen_gamma;
GLbyte *tex;
int w,h;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
if (glIsTexture(screen->bgImage) == GL_TRUE) {
glDeleteTextures(1, &screen->bgImage);
}
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GFSCR_CONF_FILE);
handle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
screen_gamma = (float)GfParmGetNum(handle, GFSCR_SECT_PROP, GFSCR_ATT_GAMMA, (char*)NULL, 2.0);
tex = (GLbyte*)GfImgReadPng(filename, &w, &h, screen_gamma);
if (!tex) {
GfParmReleaseHandle(handle);
return;
}
glGenTextures(1, &screen->bgImage);
glBindTexture(GL_TEXTURE_2D, screen->bgImage);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)(tex));
free(tex);
GfParmReleaseHandle(handle);
}
/* Register a race manager */
static void
reRegisterRaceman(tFList *racemanCur)
{
sprintf(buf, "%sconfig/raceman/%s", GetLocalDir(), racemanCur->name);
racemanCur->userData = GfParmReadFile(buf, GFPARM_RMODE_STD);
racemanCur->dispName = GfParmGetStr(racemanCur->userData, RM_SECT_HEADER, RM_ATTR_NAME, 0);
}
stringT pws_os::getuserprefsdir()
{
/**
* Returns LOCAL_APPDATA\PasswordSafe (or ...\PasswordSafeD)
* (Creating if necessary)
* If can't figure out LOCAL_APPDATA, then return an empty string
* to have Windows punt to exec dir, which is the historical behaviour
*/
#ifndef _DEBUG
const stringT sPWSDir(_T("\\PasswordSafe\\"));
#else
const stringT sPWSDir(_T("\\PasswordSafeD\\"));
#endif
stringT sDrive, sDir, sName, sExt, retval;
pws_os::splitpath(getexecdir(), sDrive, sDir, sName, sExt);
sDrive += _T("\\"); // Trailing slash required.
const UINT uiDT = ::GetDriveType(sDrive.c_str());
if (uiDT == DRIVE_FIXED || uiDT == DRIVE_REMOTE) {
stringT sLocalAppDataPath;
if (GetLocalDir(CSIDL_LOCAL_APPDATA, sLocalAppDataPath))
retval = sLocalAppDataPath + sPWSDir;
if (PathFileExists(retval.c_str()) == FALSE)
if (_tmkdir(retval.c_str()) != 0)
retval = _T(""); // couldn't create dir!?
} else if (uiDT == DRIVE_REMOVABLE) {
stringT::size_type index = sDir.rfind(_T("Program\\"));
if (index != stringT::npos)
retval = getexecdir().substr(0, getexecdir().length() - 8);
}
return retval;
}
static void
rmdsClickOnDriver(void * /* dummy */)
{
char *name;
tDrvElt *curDrv;
void *robhdle;
name = GfuiScrollListGetSelectedElement(scrHandle, selectedScrollList, (void**)&curDrv);
if (!name) {
name = GfuiScrollListGetSelectedElement(scrHandle, unselectedScrollList, (void**)&curDrv);
}
if (name) {
GfuiLabelSetText(scrHandle, PickDrvNameLabelId, curDrv->name);
/* search driver infos */
sprintf(buf, "%sdrivers/%s/%s.xml", GetLocalDir(), curDrv->dname, curDrv->dname);
robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD);
if (!robhdle) {
sprintf(buf, "drivers/%s/%s.xml", curDrv->dname, curDrv->dname);
robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD);
}
if (robhdle != NULL) {
sprintf(buf, "%s/%s/%d", ROB_SECT_ROBOTS, ROB_LIST_INDEX, curDrv->index);
GfuiLabelSetText(scrHandle, PickDrvCarLabelId, GfParmGetName(curDrv->car));
GfuiLabelSetText(scrHandle, PickDrvCategoryLabelId, GfParmGetStr(curDrv->car, SECT_CAR, PRM_CATEGORY, ""));
GfParmReleaseHandle(robhdle);
}
}
}
bool SDScenery::LoadTrack(std::string strTrack)
{
char buf[256];
GfOut("Chemin Track : %s\n", strTrack.c_str());
osgLoader loader;
GfOut("Chemin Textures : %s\n", _strTexturePath.c_str());
loader.AddSearchPath(_strTexturePath);
std::string strTPath = GetDataDir();
snprintf(buf, 256, "data/textures/");
strTPath += buf;
loader.AddSearchPath(strTPath);
osg::Node *pTrack = loader.Load3dFile(strTrack, false);
if (pTrack)
{
pTrack->getOrCreateStateSet()->setRenderBinDetails(TRACKBIN,"RenderBin");
_scenery->addChild(pTrack);
#if 0
std::string Tpath = GetLocalDir();
Tpath = Tpath+"/track.osg";
osgDB::writeNodeFile( *pTrack, Tpath);
#endif
}
else
return false;
return true;
}
void
ReInitResults(void)
{
struct tm *stm;
time_t t;
void *results;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
t = time(NULL);
stm = localtime(&t);
snprintf(buf, BUFSIZE, "%sresults/%s/results-%4d-%02d-%02d-%02d-%02d-%02d.xml",
GetLocalDir(),
ReInfo->_reFilename,
stm->tm_year+1900,
stm->tm_mon+1,
stm->tm_mday,
stm->tm_hour,
stm->tm_min,
stm->tm_sec
);
ReInfo->results = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
results = ReInfo->results;
GfParmSetNum(results, RE_SECT_HEADER, RE_ATTR_DATE, NULL, (tdble)t);
GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1);
GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1);
GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_DRIVER, NULL, 1);
}
stringT pws_os::getsafedir(void)
{
stringT sDrive, sDir, sName, sExt, retval;
pws_os::splitpath(getexecdir(), sDrive, sDir, sName, sExt);
const stringT sDriveT = sDrive + _T("\\"); // Trailing slash required.
const UINT uiDT = ::GetDriveType(sDriveT.c_str());
if (uiDT == DRIVE_REMOVABLE) {
stringT::size_type index = sDir.rfind(_T("Program\\"));
if (index != stringT::npos) {
sDir.replace(index, 8, stringT(_T("Safes\\")));
retval = sDrive + sDir;
if (PathFileExists(retval.c_str()) == TRUE)
return retval;
}
}
stringT sLocalSafePath;
if (GetLocalDir(CSIDL_PERSONAL, sLocalSafePath)) {
retval = sLocalSafePath + _T("\\My Safes");
if (PathFileExists(retval.c_str()) == FALSE)
if (_tmkdir(retval.c_str()) != 0)
retval = _T(""); // couldn't create dir!?
}
return retval;
}
extern "C" int
human(tModInfo *modInfo)
{
int i;
const char *driver;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
char sstring[BUFSIZE];
memset(modInfo, 0, 10*sizeof(tModInfo));
snprintf(buf, BUFSIZE, "%sdrivers/human/human.xml", GetLocalDir());
void *DrvInfo = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
if (DrvInfo != NULL) {
for (i = 0; i < 10; i++) {
snprintf(sstring, BUFSIZE, "Robots/index/%d", i+1);
driver = GfParmGetStr(DrvInfo, sstring, "name", "");
if (strlen(driver) == 0) {
break;
}
modInfo->name = strdup(driver); /* name of the module (short) */
modInfo->desc = strdup("Joystick controlable driver"); /* description of the module (can be long) */
modInfo->fctInit = InitFuncPt; /* init function */
modInfo->gfId = ROB_IDENT; /* supported framework version */
modInfo->index = i+1;
modInfo++;
}
// Just release in case we got it.
GfParmReleaseHandle(DrvInfo);
}
return 0;
}
// Read sound configuration.
static void readSoundCfg(void)
{
const char *optionName;
int i;
char buf[1024];
sprintf(buf, "%s%s", GetLocalDir(), GR_SOUND_PARM_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
optionName = GfParmGetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[0]);
for (i = 0; i < nbOptions; i++) {
if (strcmp(optionName, soundOptionList[i]) == 0) {
curOption = i;
break;
}
}
VolumeValue = GfParmGetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", 100.0f);
if (VolumeValue>100.0f) {
VolumeValue = 100.0f;
}
if (VolumeValue < 0.0f) {
VolumeValue = 0.0f;
}
GfParmReleaseHandle(paramHandle);
GfuiLabelSetText(scrHandle, SoundOptionId, soundOptionList[curOption]);
}
wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
{
#ifdef __VMS__ // On VMS I saw the problem that the home directory was appended
// twice for the configuration file. Does that also happen for other
// platforms?
wxString str = wxT( '.' );
#else
wxString str = GetLocalDir();
#endif
#if defined( __UNIX__ ) && !defined( __VMS )
str << wxT('.');
#endif
str << szFile;
#ifdef __WXMSW__
if ( wxStrchr(szFile, wxT('.')) == NULL )
str << wxT(".ini");
#endif
#ifdef __WXMAC__
str << " Preferences";
#endif
return str;
}
static void
gfuiColorInit(void)
{
void *hdle;
int i, j;
char *rgba[4] = {GFSCR_ATTR_RED, GFSCR_ATTR_GREEN, GFSCR_ATTR_BLUE, GFSCR_ATTR_ALPHA};
char *clr[GFUI_COLORNB] = {
GFSCR_ELT_BGCOLOR, GFSCR_ELT_TITLECOLOR, GFSCR_ELT_BGBTNFOCUS, GFSCR_ELT_BGBTNCLICK,
GFSCR_ELT_BGBTNENABLED, GFSCR_ELT_BGBTNDISABLED, GFSCR_ELT_BTNFOCUS, GFSCR_ELT_BTNCLICK,
GFSCR_ELT_BTNENABLED, GFSCR_ELT_BTNDISABLED, GFSCR_ELT_LABELCOLOR, GFSCR_ELT_TIPCOLOR,
GFSCR_ELT_MOUSECOLOR1, GFSCR_ELT_MOUSECOLOR2, GFSCR_ELT_HELPCOLOR1, GFSCR_ELT_HELPCOLOR2,
GFSCR_ELT_BGSCROLLIST, GFSCR_ELT_SCROLLIST, GFSCR_ELT_BGSELSCROLLIST, GFSCR_ELT_SELSCROLLIST,
GFSCR_ELT_EDITCURSORCLR
};
sprintf(buf, "%s%s", GetLocalDir(), GFSCR_CONF_FILE);
hdle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
for (i = 0; i < GFUI_COLORNB; i++) {
for (j = 0; j < 4; j++) {
sprintf(buf, "%s/%s/%s", GFSCR_SECT_MENUCOL, GFSCR_LIST_COLORS, clr[i]);
GfuiColor[i][j] = GfParmGetNum(hdle, buf, rgba[j], (char*)NULL, 1.0);
}
}
GfParmReleaseHandle(hdle);
/* Remove the X11/Windows cursor */
if (!GfuiMouseHW) {
glutSetCursor(GLUT_CURSOR_NONE);
}
GfuiMouseVisible = 1;
}
// Read sound configuration.
static void readSoundCfg(void)
{
const char *optionName;
int i;
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);
optionName = GfParmGetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[0]);
for (i = 0; i < nbOptions; i++) {
if (strcmp(optionName, soundOptionList[i]) == 0) {
curOption = i;
break;
}
}
VolumeValue = GfParmGetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", 100.0f);
if (VolumeValue>100.0f) {
VolumeValue = 100.0f;
}
if (VolumeValue < 0.0f) {
VolumeValue = 0.0f;
}
GfParmReleaseHandle(paramHandle);
GfuiLabelSetText(scrHandle, SoundOptionId, soundOptionList[curOption]);
// Read Menu music optons
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), MM_SOUND_PARM_CFG);
paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
optionName = GfParmGetStr(paramHandle, MM_SCT_SOUND, MM_ATT_SOUND_ENABLE, MM_VAL_SOUND_DISABLED);
if (strcmp(optionName, MM_VAL_SOUND_ENABLED) == 0) {
GfuiLabelSetText(scrHandle, MenuMusicOptionId, MM_VAL_SOUND_ENABLED);
curOptionMenuMusic = 1;
} else {
GfuiLabelSetText(scrHandle, MenuMusicOptionId, MM_VAL_SOUND_DISABLED);
curOptionMenuMusic = 0;
}
GfParmReleaseHandle(paramHandle);
}
static void
reSelectLoadFile(char *filename)
{
sprintf(buf, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename);
GfOut("Loading Saved File %s...\n", buf);
ReInfo->results = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
ReInfo->_reRaceName = ReInfo->_reName;
RmShowStandings(ReInfo->_reGameScreen, ReInfo);
}
void getUserTextureMaxSize(int &result)
{
char fnbuf[1024];
sprintf(fnbuf, "%s%s", GetLocalDir(), GR_PARAM_FILE);
void *paramHandle = GfParmReadFile(fnbuf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
result = (int) GfParmGetNum(paramHandle, GR_SCT_GLFEATURES, GR_ATT_TEXTURESIZE, (char*)NULL, (tdble) glTextureMaxSize);
if (result > glTextureMaxSize) {
result = glTextureMaxSize;
}
GfParmReleaseHandle(paramHandle);
}
/* 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;
}
// constructor supports creation of wxFileConfig objects of any type
wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
const wxString& strLocal, const wxString& strGlobal,
long style)
: wxConfigBase(::GetAppName(appName), vendorName,
strLocal, strGlobal,
style),
m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
{
// Make up names for files if empty
if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
{
m_strLocalFile = GetLocalFileName(GetAppName());
}
if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
{
m_strGlobalFile = GetGlobalFileName(GetAppName());
}
// Check if styles are not supplied, but filenames are, in which case
// add the correct styles.
if ( !m_strLocalFile.IsEmpty() )
SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
if ( !m_strGlobalFile.IsEmpty() )
SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
// if the path is not absolute, prepend the standard directory to it
// UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
{
if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
{
wxString strLocal = m_strLocalFile;
m_strLocalFile = GetLocalDir();
m_strLocalFile << strLocal;
}
if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
{
wxString strGlobal = m_strGlobalFile;
m_strGlobalFile = GetGlobalDir();
m_strGlobalFile << strGlobal;
}
}
SetUmask(-1);
Init();
}
// 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;
}
static void
SaveGraphicOptions(void *prevMenu)
{
sprintf(buf, "%s%s", GetLocalDir(), GR_PARAM_FILE);
void * grHandle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_FOVFACT, "%", FovFactorValue);
GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_SMOKENB, NULL, SmokeValue);
GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_MAXSTRIPBYWHEEL, NULL, SkidValue);
GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_LODFACTOR, NULL, LodFactorValue);
GfParmWriteFile(NULL, grHandle, "graph");
GfParmReleaseHandle(grHandle);
ExitGraphicOptions(prevMenu);
}
FILE* SegLearn::tryKarmaFilename(char* buffer, int size, const char *path, int driverindex, const char *tbuf, bool storelocalfilename)
{
// First construct a path to the local directory ($HOME/...).
snprintf(buffer, size, path, GetLocalDir(), driverindex, tbuf);
if (storelocalfilename == true) {
strncpy(filename, buffer, sizeof(filename));
}
// Try to open the local file.
FILE* fd;
if ((fd = fopen(buffer, "rb")) != NULL) {
return fd;
}
// Not found, try the global path.
snprintf(buffer, size, path, GetDataDir(), driverindex, tbuf);
return fopen(buffer, "rb");
}
static void
reLoadMenu(void *prevHandle)
{
char *str;
void *params = ReInfo->params;
fs.prevScreen = prevHandle;
fs.select = reSelectLoadFile;
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);
}
void TemplateDlg::Load(const Vector<String>& p, bool main)
{
pt.Clear();
for(int i = 0; i < p.GetCount(); i++) {
LoadNest(p[i], main);
nest.Add(p[i]);
}
LoadNest(GetLocalDir(), main);
LoadNest(GetFileFolder(ConfigFile("x")), main, false);
Sort(pt, FieldRelation(&PackageTemplate::name, StdLess<String>()));
templist.Clear();
templist.Add("<empty>");
for(int i = 0; i < pt.GetCount(); i++)
templist.Add(pt[i].name);
if(nest.GetCount())
nest.SetIndex(0);
templist.GoBegin();
ActiveFocus(package);
}
/* Race Engine Initialization */
void
ReInit(void)
{
char *dllname;
char key[256];
tRmMovieCapture *capture;
ReShutdown();
ReInfo = (tRmInfo *)calloc(1, sizeof(tRmInfo));
ReInfo->s = (tSituation *)calloc(1, sizeof(tSituation));
ReInfo->modList = &ReRaceModList;
char buf[1024];
snprintf(buf, 1024, "%s%s", GetLocalDir(), RACE_ENG_CFG);
ReInfo->_reParam = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfOut("Loading Track Loader...\n");
dllname = GfParmGetStr(ReInfo->_reParam, "Modules", "track", "");
sprintf(key, "%smodules/track/%s.%s", GetLibDir (), dllname, DLLEXT);
if (GfModLoad(0, key, &reEventModList)) return;
reEventModList->modInfo->fctInit(reEventModList->modInfo->index, &ReInfo->_reTrackItf);
GfOut("Loading Graphic Engine...\n");
dllname = GfParmGetStr(ReInfo->_reParam, "Modules", "graphic", "");
sprintf(key, "%smodules/graphic/%s.%s", GetLibDir (), dllname, DLLEXT);
if (GfModLoad(0, key, &reEventModList)) return;
reEventModList->modInfo->fctInit(reEventModList->modInfo->index, &ReInfo->_reGraphicItf);
capture = &(ReInfo->movieCapture);
if (strcmp(GfParmGetStr(ReInfo->_reParam, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_ENABLE, "no"), "no") == 0){
capture->enabled = 0;
} else {
capture->enabled = 1;
capture->state = 0;
capture->deltaFrame = 1.0 / GfParmGetNum(ReInfo->_reParam, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_FPS, NULL, 1.0);
capture->outputBase = GfParmGetStr(ReInfo->_reParam, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_OUT_DIR, "/tmp");
capture->deltaSimu = RCM_MAX_DT_SIMU;
}
ReInfo->_reGameScreen = ReHookInit();
}
// name: getFileHandle
// Obtains the file handle for the robot XML file,
// trying the installation path first, then
// the global one, if the previous attempt failed.
// @param
// @return file handler for the robot XML file
void* getFileHandle()
{
// First we try to use the directories relative to the installation path
snprintf(pathBuffer, BUFSIZE, "%sdrivers/%s/%s.xml",
GetLocalDir(), robot_name, robot_name);
// Test local installation path
void *robot_settings = GfParmReadFile(xml_path, GFPARM_RMODE_STD);
if (!robot_settings)
{
// If not found, use global installation path
snprintf(pathBuffer, BUFSIZE, "%sdrivers/%s/%s.xml",
GetDataDir(), robot_name, robot_name);
robot_settings = GfParmReadFile(xml_path, GFPARM_RMODE_STD);
}
return robot_settings;
}
void Ide::SyncUsc()
{
CleanUsc();
if(IsNull(main))
return;
::Workspace wspc;
wspc.Scan(main);
int i;
for(i = 0; i < wspc.GetCount(); i++) {
const Package& p = wspc.GetPackage(i);
for(int j = 0; j < p.file.GetCount(); j++) {
String file = SourcePath(wspc[i], p.file[j]);
if(ToLower(GetFileExt(file)) == ".usc")
UscFile(file);
}
}
UscProcessDir(GetLocalDir());
UscProcessDir(GetFileFolder(ConfigFile("x")));
}
/** Save a screen shot in png format.
@ingroup screen
*/
void
GfuiScreenShot(void * /* notused */)
{
unsigned char *img;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
struct tm *stm;
time_t t;
int sw, sh, vw, vh;
char path[BUFSIZE];
snprintf(path, BUFSIZE, "%sscreenshots", GetLocalDir());
// Ensure that screenshot directory exists.
if (GfCreateDir(path) == GF_DIR_CREATED) {
GfScrGetSize(&sw, &sh, &vw, &vh);
img = (unsigned char*)malloc(vw * vh * 3);
if (img == NULL) {
return;
}
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadBuffer(GL_FRONT);
glReadPixels((sw-vw)/2, (sh-vh)/2, vw, vh, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)img);
t = time(NULL);
stm = localtime(&t);
snprintf(buf, BUFSIZE, "%s/torcs-%4d%02d%02d%02d%02d%02d.png",
path,
stm->tm_year+1900,
stm->tm_mon+1,
stm->tm_mday,
stm->tm_hour,
stm->tm_min,
stm->tm_sec);
GfImgWritePng(img, buf, vw, vh);
free(img);
}
}
// Save the choosen values in the corresponding parameter file.
static void saveOpenGLOption(void *)
{
const int BUFSIZE = 1024;
char buf[BUFSIZE];
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GR_PARAM_FILE);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
// Texture compression.
GfParmSetStr(paramHandle, GR_SCT_GLFEATURES, GR_ATT_TEXTURECOMPRESSION, textureCompressOptionList[curOptionTextComp]);
// Texture sizing.
GfParmSetNum(paramHandle, GR_SCT_GLFEATURES, GR_ATT_TEXTURESIZE, (char*)NULL, (tdble) textureSizeOptionList[curOptionTextSize]);
GfParmWriteFile(NULL, paramHandle, "graph");
GfParmReleaseHandle(paramHandle);
// Return to previous screen.
GfuiScreenActivate(prevHandle);
updateCompressARBEnabled();
updateUserTextureMaxSize();
return;
}
