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; }