void FGameConfigFile::CreateStandardAutoExec(const char *section, bool start) { if (!SetSection(section)) { FString path; #ifdef __APPLE__ char cpath[PATH_MAX]; FSRef folder; if (noErr == FSFindFolder(kUserDomain, kDocumentsFolderType, kCreateFolder, &folder) && noErr == FSRefMakePath(&folder, (UInt8*)cpath, PATH_MAX)) { path << cpath << "/" GAME_DIR "/autoexec.cfg"; } #elif !defined(unix) path = "$PROGDIR/autoexec.cfg"; #else path = GetUserFile ("autoexec.cfg"); #endif SetSection (section, true); SetValueForKey ("Path", path.GetChars()); } if (start) { MoveSectionToStart(section); } }
void FGameConfigFile::DoGameSetup (const char *gamename) { const char *key; const char *value; sublen = countof(section) - 1 - mysnprintf (section, countof(section), "%s.", gamename); subsection = section + countof(section) - sublen - 1; section[countof(section) - 1] = '\0'; strncpy (subsection, "UnknownConsoleVariables", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "ConsoleVariables", sublen); if (SetSection (section)) { ReadCVars (0); } if (gameinfo.gametype & GAME_Raven) { SetRavenDefaults (gameinfo.gametype == GAME_Hexen); } // The NetServerInfo section will be read and override anything loaded // here when it's determined that a netgame is being played. strncpy (subsection, "LocalServerInfo", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "Player", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "ConsoleAliases", sublen); if (SetSection (section)) { const char *name = NULL; while (NextInSection (key, value)) { if (stricmp (key, "Name") == 0) { name = value; } else if (stricmp (key, "Command") == 0 && name != NULL) { C_SetAlias (name, value); name = NULL; } } } OkayToWrite = true; }
void FGameConfigFile::CreateStandardAutoExec(const char *section, bool start) { if (!SetSection(section)) { FString path = M_GetAutoexecPath(); SetSection (section, true); SetValueForKey ("Path", path.GetChars()); } if (start) { MoveSectionToStart(section); } }
void FGameConfigFile::ArchiveGlobalData () { SetSection ("LastRun", true); ClearCurrentSection (); SetValueForKey ("Version", LASTRUNVERSION); SetSection ("GlobalSettings", true); ClearCurrentSection (); C_ArchiveCVars (this, 1); SetSection ("GlobalSettings.Unknown", true); ClearCurrentSection (); C_ArchiveCVars (this, 3); }
void FGameConfigFile::ArchiveGlobalData () { SetSection ("LastRun", true); ClearCurrentSection (); SetValueForKey ("Version", LASTRUNVERSION); SetSection ("GlobalSettings", true); ClearCurrentSection (); C_ArchiveCVars (this, CVAR_ARCHIVE|CVAR_GLOBALCONFIG); SetSection ("GlobalSettings.Unknown", true); ClearCurrentSection (); C_ArchiveCVars (this, CVAR_ARCHIVE|CVAR_GLOBALCONFIG|CVAR_AUTO); }
// Like DoGameSetup(), but for mod-specific cvars. // Called after CVARINFO has been parsed. void FGameConfigFile::DoModSetup(const char *gamename) { mysnprintf(section, countof(section), "%s.Player.Mod", gamename); if (SetSection(section)) { ReadCVars(CVAR_MOD|CVAR_USERINFO|CVAR_IGNORE); } mysnprintf(section, countof(section), "%s.LocalServerInfo.Mod", gamename); if (SetSection (section)) { ReadCVars (CVAR_MOD|CVAR_SERVERINFO|CVAR_IGNORE); } // Signal that these sections should be rewritten when saving the config. bModSetup = true; }
cMenuSetupSc::cMenuSetupSc(const char *CfgDir) { cfgdir=strdup(CfgDir); SetSection(tr("SoftCAM")); ScOpts->Backup(); LogOpts->Backup(); for(cOpts *opts=0; (opts=cSystems::GetSystemOpts(opts==0));) opts->Backup(); ScOpts->Create(this); Add(new cOsdItem(tr("Cryptsystem options..."),osUser5)); Add(new cOsdItem(tr("Message logging..."),osUser6)); if(Feature.SmartCard()) { char id[IDSTR_LEN]; for(int i=0; smartcards.ListCard(i,id,sizeof(id)); i++) { char buff[32]; snprintf(buff,sizeof(buff),"%s %d",tr("Smartcard interface"),i); cScInfoItem *ii; if(id[0]) ii=new cScInfoItem(buff,id,osUser4); else ii=new cScInfoItem(buff,tr("(empty)")); ii->Ident(i); Add(ii); } } Add(new cOsdItem(tr("Status information..."),osUser8)); Add(new cOsdItem(tr("Flush ECM cache"),osUser7)); Add(new cOsdItem(tr("Reload files"),osUser9)); }
void FGameConfigFile::ReadNetVars () { strncpy (subsection, "NetServerInfo", sublen); if (SetSection (section)) { ReadCVars (0); } if (bModSetup) { mysnprintf(subsection, sublen, "NetServerInfo.Mod"); if (SetSection(section)) { ReadCVars(CVAR_MOD|CVAR_SERVERINFO|CVAR_IGNORE); } } }
// Moved from DoGameSetup so that it can happen after wads are loaded void FGameConfigFile::DoKeySetup(const char *gamename) { static const struct { const char *label; FKeyBindings *bindings; } binders[] = { { "Bindings", &Bindings }, { "DoubleBindings", &DoubleBindings }, { "AutomapBindings", &AutomapBindings }, { NULL, NULL } }; const char *key, *value; sublen = countof(section) - 1 - mysnprintf(section, countof(section), "%s.", gamename); subsection = section + countof(section) - sublen - 1; section[countof(section) - 1] = '\0'; C_SetDefaultBindings (); for (int i = 0; binders[i].label != NULL; ++i) { strncpy(subsection, binders[i].label, sublen); if (SetSection(section)) { FKeyBindings *bindings = binders[i].bindings; bindings->UnbindAll(); while (NextInSection(key, value)) { bindings->DoBind(key, value); } } } }
/// Set a section name /// /// @param id String ID /// void YCIni::SetSection(u32 id) { TCHAR buffer[256]; ::LoadString(::GetModuleHandle(nullptr), id, buffer, ArrayUtils::ArraySize(buffer)); SetSection(buffer); }
void FGameConfigFile::ReadNetVars () { strncpy (subsection, "NetServerInfo", sublen); if (SetSection (section)) { ReadCVars (0); } }
void FGameConfigFile::ArchiveGameData (const char *gamename) { char section[32*3], *subsection; sublen = countof(section) - 1 - mysnprintf (section, countof(section), "%s.", gamename); subsection = section + countof(section) - 1 - sublen; strncpy (subsection, "Player", sublen); SetSection (section, true); ClearCurrentSection (); C_ArchiveCVars (this, 4); strncpy (subsection, "ConsoleVariables", sublen); SetSection (section, true); ClearCurrentSection (); C_ArchiveCVars (this, 0); strncpy (subsection, netgame ? "NetServerInfo" : "LocalServerInfo", sublen); if (!netgame || consoleplayer == 0) { // Do not overwrite this section if playing a netgame, and // this machine was not the initial host. SetSection (section, true); ClearCurrentSection (); C_ArchiveCVars (this, 5); } strncpy (subsection, "UnknownConsoleVariables", sublen); SetSection (section, true); ClearCurrentSection (); C_ArchiveCVars (this, 2); strncpy (subsection, "ConsoleAliases", sublen); SetSection (section, true); ClearCurrentSection (); C_ArchiveAliases (this); M_SaveCustomKeys (this, section, subsection, sublen); strcpy (subsection, "Bindings"); SetSection (section, true); Bindings.ArchiveBindings (this); strncpy (subsection, "DoubleBindings", sublen); SetSection (section, true); DoubleBindings.ArchiveBindings (this); strncpy (subsection, "AutomapBindings", sublen); SetSection (section, true); AutomapBindings.ArchiveBindings (this); }
ClientEnAttente::ClientEnAttente(string nom, int nbDePersonnes, int sectionsChoisie) { if (sectionsChoisie > 0 && sectionsChoisie < 8) // Le choix est valide { SetNom(nom); SetSection(sectionsChoisie); SetNombreDePersonnes(nbDePersonnes); SetPrecedent(nullptr); // nullptr indique qu'on ne connait pas l'adresse; equivaut à null SetSuivant(nullptr); } else // Le choix est invalide, on lance une exception cout << "La section choisie est invalide. Choix: salle(0), terrasse(1), terrasseFumeur(2)" << endl; }
void FGameConfigFile::AddAutoexec (DArgs *list, const char *game) { char section[64]; const char *key; const char *value; mysnprintf (section, countof(section), "%s.AutoExec", game); if (bMigrating) { FBaseCVar *autoexec = FindCVar ("autoexec", NULL); if (autoexec != NULL) { UCVarValue val; char *path; val = autoexec->GetGenericRep (CVAR_String); path = copystring (val.String); delete autoexec; SetSection (section, true); SetValueForKey ("Path", path); list->AppendArg (path); delete[] path; } } else { // If <game>.AutoExec section does not exist, create it // with a default autoexec.cfg file present. CreateStandardAutoExec(section, false); // Run any files listed in the <game>.AutoExec section if (!SectionIsEmpty()) { while (NextInSection (key, value)) { if (stricmp (key, "Path") == 0 && *value != '\0') { FString expanded_path = ExpandEnvVars(value); if (FileExists(expanded_path)) { list->AppendArg (ExpandEnvVars(value)); } } } } } }
void FGameConfigFile::DoGameSetup (const char *gamename) { const char *key; const char *value; enum { Doom, Heretic, Hexen, Strife, Chex } game; if (strcmp (gamename, "Heretic") == 0) game = Heretic; else if (strcmp (gamename, "Hexen") == 0) game = Hexen; else if (strcmp (gamename, "Strife") == 0) game = Strife; else if (strcmp (gamename, "Chex") == 0) game = Chex; else game = Doom; if (bMigrating) { MigrateOldConfig (); } sublen = countof(section) - 1 - mysnprintf (section, countof(section), "%s.", gamename); subsection = section + countof(section) - sublen - 1; section[countof(section) - 1] = '\0'; strncpy (subsection, "UnknownConsoleVariables", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "ConsoleVariables", sublen); if (SetSection (section)) { ReadCVars (0); } if (game != Doom && game != Strife && game != Chex) { SetRavenDefaults (game == Hexen); } // The NetServerInfo section will be read when it's determined that // a netgame is being played. strncpy (subsection, "LocalServerInfo", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "Player", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "Bindings", sublen); if (!SetSection (section)) { // Config has no bindings for the given game if (!bMigrating) { C_SetDefaultBindings (); } } else { C_UnbindAll (); while (NextInSection (key, value)) { C_DoBind (key, value, false); } } strncpy (subsection, "DoubleBindings", sublen); if (SetSection (section)) { while (NextInSection (key, value)) { C_DoBind (key, value, true); } } strncpy (subsection, "ConsoleAliases", sublen); if (SetSection (section)) { const char *name = NULL; while (NextInSection (key, value)) { if (stricmp (key, "Name") == 0) { name = value; } else if (stricmp (key, "Command") == 0 && name != NULL) { C_SetAlias (name, value); name = NULL; } } } }
void FGameConfigFile::DoGlobalSetup () { if (SetSection ("GlobalSettings.Unknown")) { ReadCVars (CVAR_GLOBALCONFIG); } if (SetSection ("GlobalSettings")) { ReadCVars (CVAR_GLOBALCONFIG); } if (SetSection ("LastRun")) { const char *lastver = GetValueForKey ("Version"); if (lastver != NULL) { double last = atof (lastver); if (last < 123.1) { FBaseCVar *noblitter = FindCVar ("vid_noblitter", NULL); if (noblitter != NULL) { noblitter->ResetToDefault (); } } if (last < 202) { // Make sure the Hexen hotkeys are accessible by default. if (SetSection ("Hexen.Bindings")) { SetValueForKey ("\\", "use ArtiHealth"); SetValueForKey ("scroll", "+showscores"); SetValueForKey ("0", "useflechette"); SetValueForKey ("9", "use ArtiBlastRadius"); SetValueForKey ("8", "use ArtiTeleport"); SetValueForKey ("7", "use ArtiTeleportOther"); SetValueForKey ("6", "use ArtiEgg"); SetValueForKey ("5", "use ArtiInvulnerability"); } } if (last < 204) { // The old default for vsync was true, but with an unlimited framerate // now, false is a better default. FBaseCVar *vsync = FindCVar ("vid_vsync", NULL); if (vsync != NULL) { vsync->ResetToDefault (); } } if (last < 206) { // spc_amp is now a float, not an int. if (spc_amp > 16) { spc_amp = spc_amp / 16.f; } } if (last < 207) { // Now that snd_midiprecache works again, you probably don't want it on. FBaseCVar *precache = FindCVar ("snd_midiprecache", NULL); if (precache != NULL) { precache->ResetToDefault(); } } if (last < 208) { // Weapon sections are no longer used, so tidy up the config by deleting them. const char *name; size_t namelen; bool more; more = SetFirstSection(); while (more) { name = GetCurrentSection(); if (name != NULL && (namelen = strlen(name)) > 12 && strcmp(name + namelen - 12, ".WeaponSlots") == 0) { more = DeleteCurrentSection(); } else { more = SetNextSection(); } } } if (last < 209) { // menu dimming is now a gameinfo option so switch user override off FBaseCVar *dim = FindCVar ("dimamount", NULL); if (dim != NULL) { dim->ResetToDefault (); } } } } }
bool CCodeBlock::CreateBlockLinkage(CCodeSection * EnterSection) { CCodeSection * CurrentSection = EnterSection; CPU_Message("Section %d", CurrentSection->m_SectionID); for (uint32_t TestPC = EnterSection->m_EnterPC, EndPC = ((EnterSection->m_EnterPC + 0x1000) & 0xFFFFF000); TestPC <= EndPC; TestPC += 4) { if (TestPC != EndPC) { SectionMap::const_iterator itr = m_SectionMap.find(TestPC); if (itr != m_SectionMap.end() && CurrentSection != itr->second) { if (CurrentSection->m_ContinueSection != NULL && CurrentSection->m_ContinueSection != itr->second) { g_Notify->BreakPoint(__FILE__, __LINE__); } if (CurrentSection->m_ContinueSection == NULL) { SetSection(CurrentSection->m_ContinueSection, CurrentSection, TestPC, true, TestPC); CurrentSection->SetContinueAddress(TestPC - 4, TestPC); } CurrentSection->m_EndPC = TestPC - 4; CurrentSection = itr->second; CPU_Message("Section %d", CurrentSection->m_SectionID); if (EnterSection != m_EnterSection) { if (CurrentSection->m_JumpSection != NULL || CurrentSection->m_ContinueSection != NULL || CurrentSection->m_EndSection) { break; } } } } else { CurrentSection->m_EndSection = true; break; } bool LikelyBranch, EndBlock, IncludeDelaySlot, PermLoop; uint32_t TargetPC, ContinuePC; CurrentSection->m_EndPC = TestPC; if (!AnalyzeInstruction(TestPC, TargetPC, ContinuePC, LikelyBranch, IncludeDelaySlot, EndBlock, PermLoop)) { g_Notify->BreakPoint(__FILE__, __LINE__); return false; } if (TestPC + 4 == EndPC && IncludeDelaySlot) { TargetPC = (uint32_t)-1; ContinuePC = (uint32_t)-1; EndBlock = true; } if (TargetPC == (uint32_t)-1 && !EndBlock) { if (ContinuePC != (uint32_t)-1) { g_Notify->BreakPoint(__FILE__, __LINE__); } continue; } if (EndBlock) { CPU_Message("%s: End Block", __FUNCTION__); CurrentSection->m_EndSection = true; // find other sections that need compiling break; } if (ContinuePC != (uint32_t)-1) { CPU_Message("%s: SetContinueAddress TestPC = %X ContinuePC = %X", __FUNCTION__, TestPC, ContinuePC); CurrentSection->SetContinueAddress(TestPC, ContinuePC); if (!SetSection(CurrentSection->m_ContinueSection, CurrentSection, ContinuePC, true, TestPC)) { ContinuePC = (uint32_t)-1; } } if (LikelyBranch) { CPU_Message("%s: SetJumpAddress TestPC = %X Target = %X", __FUNCTION__, TestPC, TestPC + 4); CurrentSection->SetJumpAddress(TestPC, TestPC + 4, false); if (SetSection(CurrentSection->m_JumpSection, CurrentSection, TestPC + 4, false, TestPC)) { bool BranchLikelyBranch, BranchEndBlock, BranchIncludeDelaySlot, BranchPermLoop; uint32_t BranchTargetPC, BranchContinuePC; CCodeSection * JumpSection = CurrentSection->m_JumpSection; if (!AnalyzeInstruction(JumpSection->m_EnterPC, BranchTargetPC, BranchContinuePC, BranchLikelyBranch, BranchIncludeDelaySlot, BranchEndBlock, BranchPermLoop)) { g_Notify->BreakPoint(__FILE__, __LINE__); return false; } if (BranchLikelyBranch || BranchIncludeDelaySlot || BranchPermLoop) { g_Notify->BreakPoint(__FILE__, __LINE__); return false; } JumpSection->m_EndPC = TestPC + 4; if (BranchEndBlock) { CPU_Message("%s: Jump End Block", __FUNCTION__); JumpSection->m_EndSection = true; TargetPC = (uint32_t)-1; } else { JumpSection->SetJumpAddress(TestPC, TargetPC, false); } JumpSection->SetDelaySlot(); SetSection(JumpSection->m_JumpSection, JumpSection, TargetPC, true, TestPC); } else { g_Notify->BreakPoint(__FILE__, __LINE__); } } else if (TargetPC != ((uint32_t)-1)) { CPU_Message("%s: SetJumpAddress TestPC = %X Target = %X", __FUNCTION__, TestPC, TargetPC); CurrentSection->SetJumpAddress(TestPC, TargetPC, PermLoop); if (PermLoop || !SetSection(CurrentSection->m_JumpSection, CurrentSection, TargetPC, true, TestPC)) { if (ContinuePC == (uint32_t)-1) { CurrentSection->m_EndSection = true; } } } TestPC += IncludeDelaySlot ? 8 : 4; //Find the next section CCodeSection * NewSection = NULL; for (SectionMap::const_iterator itr = m_SectionMap.begin(); itr != m_SectionMap.end(); itr++) { if (CurrentSection->m_JumpSection != NULL || CurrentSection->m_ContinueSection != NULL || CurrentSection->m_EndSection) { continue; } NewSection = itr->second; break; } if (NewSection == NULL) { break; } if (CurrentSection == NewSection) { g_Notify->BreakPoint(__FILE__, __LINE__); } CurrentSection = NewSection; if (CurrentSection->m_JumpSection != NULL || CurrentSection->m_ContinueSection != NULL || CurrentSection->m_EndSection) { break; } TestPC = CurrentSection->m_EnterPC; CPU_Message("a. Section %d", CurrentSection->m_SectionID); TestPC -= 4; } for (SectionMap::iterator itr = m_SectionMap.begin(); itr != m_SectionMap.end(); itr++) { CCodeSection * Section = itr->second; if (Section->m_JumpSection != NULL || Section->m_ContinueSection != NULL || Section->m_EndSection) { continue; } if (!CreateBlockLinkage(Section)) { return false; } break; } if (CurrentSection->m_EndPC == (uint32_t)-1) { g_Notify->BreakPoint(__FILE__, __LINE__); } return true; }
//-------------------------------------------------------------------- double CIniFile::ReadFloat(const std::wstring& szSection, const std::wstring& szKey, double lfDefault) { SetSection(szSection); return ReadFloat(szKey, lfDefault); }
/* Init() */ void CConfig::CONFIG::Init(LPCSTR lpcszSectionName/*=NULL*/,LPCSTR lpcszKeyName/*=NULL*/,DWORD dwKeyValue/*=(DWORD)-1L*/) { SetSection(lpcszSectionName); SetName(lpcszKeyName); SetValue(dwKeyValue); }
//-------------------------------------------------------------------- bool CIniFile::SafeReadBoolean(const std::wstring& szSection, const std::wstring& szKey) throw(CIniException) { SetSection(szSection); return SafeReadBoolean(szKey); }
void BaseSearchMgr::SetSection(BaseSearcher* pBaseSearcher,U16 pid,U8 table_id,const U8* pBuffer,U32 iSize) { DVBSection *pSection = new DVBSection(pBaseSearcher,pid,table_id,pBuffer,iSize); SetSection(pSection); }
void FGameConfigFile::DoGameSetup (const char *gamename) { const char *key; const char *value; if (bMigrating) { MigrateOldConfig (); } sublen = countof(section) - 1 - mysnprintf (section, countof(section), "%s.", gamename); subsection = section + countof(section) - sublen - 1; section[countof(section) - 1] = '\0'; strncpy (subsection, "UnknownConsoleVariables", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "ConsoleVariables", sublen); if (SetSection (section)) { ReadCVars (0); } if (gameinfo.gametype & GAME_Raven) { SetRavenDefaults (gameinfo.gametype == GAME_Hexen); } // The NetServerInfo section will be read when it's determined that // a netgame is being played. strncpy (subsection, "LocalServerInfo", sublen); if (SetSection (section)) { ReadCVars (0); } strncpy (subsection, "Player", sublen); if (SetSection (section)) { ReadCVars (0); } if (!bMigrating) { C_SetDefaultBindings (); } strncpy (subsection, "Bindings", sublen); if (SetSection (section)) { Bindings.UnbindAll(); while (NextInSection (key, value)) { Bindings.DoBind (key, value); } } strncpy (subsection, "DoubleBindings", sublen); if (SetSection (section)) { DoubleBindings.UnbindAll(); while (NextInSection (key, value)) { DoubleBindings.DoBind (key, value); } } strncpy (subsection, "AutomapBindings", sublen); if (SetSection (section)) { AutomapBindings.UnbindAll(); while (NextInSection (key, value)) { AutomapBindings.DoBind (key, value); } } strncpy (subsection, "ConsoleAliases", sublen); if (SetSection (section)) { const char *name = NULL; while (NextInSection (key, value)) { if (stricmp (key, "Name") == 0) { name = value; } else if (stricmp (key, "Command") == 0 && name != NULL) { C_SetAlias (name, value); name = NULL; } } } OkayToWrite = true; }
//-------------------------------------------------------------------- double CIniFile::SafeReadFloat(const std::wstring& szSection, const std::wstring& szKey) throw(CIniException) { SetSection(szSection); return SafeReadFloat(szKey); }
//-------------------------------------------------------------------- void CIniFile::WriteInteger(const std::wstring& szSection, const std::wstring& szKey, int nValue) { SetSection(szSection); WriteInteger(szKey, nValue); }
//-------------------------------------------------------------------- void CIniFile::WriteString(const std::wstring& szSection, const std::wstring& szKey, const std::wstring& szValue) { SetSection(szSection); WriteString(szKey, szValue); }
//-------------------------------------------------------------------- int CIniFile::SafeReadInteger(const std::wstring& szSection, const std::wstring& szKey) throw( CIniException ) { SetSection( szSection ); return SafeReadInteger( szKey ); }
//-------------------------------------------------------------------- void CIniFile::WriteFloat(const std::wstring& szSection, const std::wstring& szKey, double lfValue) { SetSection( szSection ); WriteFloat( szKey, lfValue ); }
//-------------------------------------------------------------------- bool CIniFile::ReadBoolean(const std::wstring& szSection, const std::wstring& szKey, bool bDefault) { SetSection(szSection); return ReadBoolean(szKey, bDefault); }
FGameConfigFile::FGameConfigFile () { #ifdef __APPLE__ FString user_docs, user_app_support, local_app_support; #endif FString pathname; bMigrating = false; pathname = GetConfigPath (true); ChangePathName (pathname); LoadConfigFile (MigrateStub, NULL); if (!HaveSections ()) { // Config file not found; try the old one MigrateOldConfig (); } // If zdoom.ini was read from the program directory, switch // to the user directory now. If it was read from the user // directory, this effectively does nothing. pathname = GetConfigPath (false); ChangePathName (pathname); // Set default IWAD search paths if none present if (!SetSection ("IWADSearch.Directories")) { SetSection ("IWADSearch.Directories", true); SetValueForKey ("Path", ".", true); SetValueForKey ("Path", "$DOOMWADDIR", true); #ifdef __APPLE__ char cpath[PATH_MAX]; FSRef folder; if (noErr == FSFindFolder(kUserDomain, kDocumentsFolderType, kCreateFolder, &folder) && noErr == FSRefMakePath(&folder, (UInt8*)cpath, PATH_MAX)) { user_docs << cpath << "/" GAME_DIR; SetValueForKey("Path", user_docs, true); } else { SetValueForKey("Path", "~/" GAME_DIR, true); } if (noErr == FSFindFolder(kUserDomain, kApplicationSupportFolderType, kCreateFolder, &folder) && noErr == FSRefMakePath(&folder, (UInt8*)cpath, PATH_MAX)) { user_app_support << cpath << "/" GAME_DIR; SetValueForKey("Path", user_app_support, true); } SetValueForKey ("Path", "$PROGDIR", true); if (noErr == FSFindFolder(kLocalDomain, kApplicationSupportFolderType, kCreateFolder, &folder) && noErr == FSRefMakePath(&folder, (UInt8*)cpath, PATH_MAX)) { local_app_support << cpath << "/" GAME_DIR; SetValueForKey("Path", local_app_support, true); } #elif !defined(unix) SetValueForKey ("Path", "$HOME", true); SetValueForKey ("Path", "$PROGDIR", true); #else SetValueForKey ("Path", "~/" GAME_DIR, true); SetValueForKey ("Path", SHARE_DIR, true); #endif } // Set default search paths if none present if (!SetSection ("FileSearch.Directories")) { SetSection ("FileSearch.Directories", true); #ifdef __APPLE__ SetValueForKey ("Path", user_docs, true); SetValueForKey ("Path", user_app_support, true); SetValueForKey ("Path", "$PROGDIR", true); SetValueForKey ("Path", local_app_support, true); #elif !defined(unix) SetValueForKey ("Path", "$PROGDIR", true); #else SetValueForKey ("Path", SHARE_DIR, true); #endif SetValueForKey ("Path", "$DOOMWADDIR", true); } // Create auto-load sections, so users know what's available. // Note that this totem pole is the reverse of the order that // they will appear in the file. CreateSectionAtStart("Chex3.Autoload"); CreateSectionAtStart("Chex.Autoload"); CreateSectionAtStart("Strife.Autoload"); CreateSectionAtStart("HexenDemo.Autoload"); CreateSectionAtStart("HexenDK.Autoload"); CreateSectionAtStart("Hexen.Autoload"); CreateSectionAtStart("Heretic.Autoload"); CreateSectionAtStart("FreeDM.Autoload"); CreateSectionAtStart("Freedoom1.Autoload"); CreateSectionAtStart("Freedoom.Autoload"); CreateSectionAtStart("Plutonia.Autoload"); CreateSectionAtStart("TNT.Autoload"); CreateSectionAtStart("Doom2.Autoload"); CreateSectionAtStart("Doom1.Autoload"); CreateSectionAtStart("Doom.Autoload"); CreateSectionAtStart("Global.Autoload"); // The same goes for auto-exec files. CreateStandardAutoExec("Chex.AutoExec", true); CreateStandardAutoExec("Strife.AutoExec", true); CreateStandardAutoExec("Hexen.AutoExec", true); CreateStandardAutoExec("Heretic.AutoExec", true); CreateStandardAutoExec("Doom.AutoExec", true); // Move search paths back to the top. MoveSectionToStart("FileSearch.Directories"); MoveSectionToStart("IWADSearch.Directories"); // Add some self-documentation. SetSectionNote("IWADSearch.Directories", "# These are the directories to automatically search for IWADs.\n" "# Each directory should be on a separate line, preceded by Path=\n"); SetSectionNote("FileSearch.Directories", "# These are the directories to search for wads added with the -file\n" "# command line parameter, if they cannot be found with the path\n" "# as-is. Layout is the same as for IWADSearch.Directories\n"); SetSectionNote("Doom.AutoExec", "# Files to automatically execute when running the corresponding game.\n" "# Each file should be on its own line, preceded by Path=\n\n"); SetSectionNote("Global.Autoload", "# WAD files to always load. These are loaded after the IWAD but before\n" "# any files added with -file. Place each file on its own line, preceded\n" "# by Path=\n"); SetSectionNote("Doom.Autoload", "# Wad files to automatically load depending on the game and IWAD you are\n" "# playing. You may have have files that are loaded for all similar IWADs\n" "# (the game) and files that are only loaded for particular IWADs. For example,\n" "# any files listed under Doom.Autoload will be loaded for any version of Doom,\n" "# but files listed under Doom2.Autoload will only load when you are\n" "# playing Doom 2.\n\n"); }
//-------------------------------------------------------------------- void CIniFile::WriteBoolean(const std::wstring& szSection, const std::wstring& szKey, bool bValue) { SetSection( szSection ); WriteFloat( szKey, bValue ); }