std::string FConfigVariableManager::GetConfigurationFileName() const { char FileNameBuffer[256]; GetModuleFileName(nullptr, FileNameBuffer, sizeof(FileNameBuffer)); std::string ConfigurationFileName = RemoveExtension(GetNameFromPath(FileNameBuffer)); return ConfigurationFileName + ".ini"; }
void checkOutput(Parameters& par) { if (!*par.outfile) { RemoveExtension(par.outfile, par.infile); strcat(par.outfile, ".hhr"); HH_LOG(INFO) << "Search results will be written to " << par.outfile << "\n"; } }
HRESULT GetAddInName(std::wstring& addInName) { HRESULT hr; std::wstring header; std::wstring clrVersion; bool shadowCopyFiles; std::wstring createSandboxedAppDomainValue; hr = GetDnaHeader(false, header); // Don't show errors here. if (!FAILED(hr)) { hr = ParseDnaHeader(header, addInName, clrVersion, shadowCopyFiles, createSandboxedAppDomainValue); // No errors yet. if (FAILED(hr)) { return E_FAIL; } if (addInName.empty()) { std::wstring xllPath(GetAddInFullPath()); StripPath(xllPath); RemoveExtension(xllPath); addInName = xllPath; } } return hr; }
CStdString LocalTempCopyOfFile::FixUnicodeFileNameForXP(CStdString sFileName) { char *ansistr; int lenW = (int)sFileName.length(); int lenA = ::WideCharToMultiByte(CP_ACP, 0, sFileName.c_str(), lenW, 0, 0, NULL, NULL); if (lenA > 0) { ansistr = new char[lenA + 1]; // allocate a final null terminator as well BOOL bDefaultCharUsed = FALSE; ::WideCharToMultiByte(CP_ACP, 0, sFileName.c_str(), lenW, ansistr, lenA, NULL, &bDefaultCharUsed); ansistr[lenA] = 0; // Set the null terminator CStdString sRetVal(ansistr); if ( bDefaultCharUsed && IsFullyMessedUpString(sRetVal) ) { TCHAR szTempFileBuffer[MAX_PATH]; ::GetTempFileName(m_sTempFolder, _T("wmtemp"), rand(), szTempFileBuffer ); sRetVal = ::PathFindFileName(szTempFileBuffer); sRetVal = RemoveExtension(sRetVal); sRetVal += ::PathFindExtension(sFileName.c_str()); } delete[] ansistr; return sRetVal; } return _T(""); }
/** * This function update the mirror's databases, if one is supplied only that's updated, otherwise all mirrors. * @param name A database name (if NULL, then all databases) * @return If no error ocurr, 0 is returned. If the database given doesn't exists, 1 is returned. In case of error, -1 (And an error message is issued) */ int UpdateMirrorDB(char *db) { int i = 0, fd = 0; char dbpath[PATH_MAX]; char dbLink[PATH_MAX]; char dbDesc[PATH_MAX]; DIR *dip; struct dirent *dit; /* If only one database was issued */ if (db) { /* Get the path */ snprintf(dbpath, PATH_MAX, "%s/%s.kdb", MIRRORS_DIRECTORY, db); if ((fd = open(dbpath, O_RDONLY)) < 0) { fprintf(stdout, "Database %s doesn't exists\n", db); return 1; } close(fd); /* Get its data */ memset(dbLink, '\0', sizeof(dbLink)); memset(dbDesc, '\0', sizeof(dbDesc)); if (GetDataFromMirrorDatabase(dbpath, "LINK", dbLink) == -1) return -1; if (GetDataFromMirrorDatabase(dbpath, "DESC", dbDesc) == -1) return -1; /* Show comments for this database if any */ if (dbDesc[0] != '\0') fprintf(stdout, "Comments for [%s]:\n%s\n", db, dbDesc); /* Get the database! */ if (dbLink[0] != '\0') if (Download(dbLink, dbpath) == -1) return -1; return 0; } /* Get the databases from the directories */ if ((dip = opendir(MIRRORS_DIRECTORY)) == NULL) { fprintf(stderr, "Couldn't open the mirror's database directory %s (%s)\n", MIRRORS_DIRECTORY, strerror(errno)); return -1; } i = 1; while ((dit = readdir(dip)) != NULL) { /* Skip directories . and .. */ if (!strcmp(dit->d_name, ".") || !strcmp(dit->d_name, "..")) continue; if (!UpdateMirrorDB(RemoveExtension(dit->d_name))) i = 0; } closedir(dip); return i; }
bool C4VectorFont::Init(C4Group &hGrp, const char *szFilename, C4Config &rCfg) { // name by file Name.Copy(GetFilenameOnly(szFilename)); #if defined(_WIN32) && !defined(HAVE_FREETYPE) // check whether group is directory or packed if (!hGrp.IsPacked()) { // it's open: use the file directly SCopy(hGrp.GetFullName().getData(), FileName, _MAX_PATH); AppendBackslash(FileName); SAppend(szFilename, FileName); if (!FileExists(FileName)) { *FileName=0; return false; } fIsTempFile = false; } else { // it's packed: extract to temp path SCopy(rCfg.AtTempPath(szFilename), FileName, _MAX_PATH); // make sure the filename is not in use, in case multiple instances of the engine are run if (FileExists(FileName)) { RemoveExtension(FileName); StdStrBuf sNewFilename; for (int i=0; i<1000; ++i) { sNewFilename.Format("%s%x", FileName, (int)rand()); if (*GetExtension(szFilename)) { sNewFilename.AppendChar('.'); sNewFilename.Append(GetExtension(szFilename)); } if (!FileExists(sNewFilename.getData())) break; } SCopy(sNewFilename.getData(), FileName, _MAX_PATH); } if (!hGrp.ExtractEntry(szFilename, FileName)) { *FileName=0; return false; } fIsTempFile = true; } // add the font resource //if (!AddFontResourceEx(FileName, FR_PRIVATE, NULL)) requires win2k if (!AddFontResource(FileName)) { if (fIsTempFile) EraseFile(FileName); *FileName='\0'; return false; } #else if (!hGrp.LoadEntry(szFilename, Data)) return false; #endif // success return true; }
CFilePath &CFilePath::RenameExtension(LPCTSTR psNewExt) { if (psNewExt == NULL || *psNewExt != '.') { RemoveExtension(); return AddExtension(psNewExt); } int nMaxLen = msPath.GetLength() + _tcslen(psNewExt) + 1; PathRenameExtension(CStringLock(msPath, nMaxLen), psNewExt); return *this; }
//--------------------------------------------------------------------------- __fastcall TFormScoreTests::TFormScoreTests(TComponent* Owner) : TForm(Owner) { StringGridStudents->Cells[0][0] = "#"; StringGridStudents->Cells[1][0] = "Name"; StringGridStudents->Cells[2][0] = "Score"; StringGridStudents->Cells[3][0] = "Comment"; StringGridQuestions->Cells[0][0] = "#"; StringGridQuestions->Cells[1][0] = "f"; StringGridQuestions->Cells[2][0] = "Question"; assert(RemovePath("Test.txt")=="Test.txt"); assert(RemovePath("C:\\Test.txt")=="Test.txt"); assert(RemovePath("C:\\Test\\Test.txt")=="Test.txt"); assert(RemovePath("C:\\Test\\Test\\Test.txt")=="Test.txt"); assert(RemoveExtension("Test.txt")=="Test"); assert(RemoveExtension("C:\\Test.txt")=="C:\\Test"); assert(RemoveExtension("C:\\Test\\Test.txt")=="C:\\Test\\Test"); assert(RemoveExtension("C:\\Test\\Test\\Test.txt")=="C:\\Test\\Test\\Test"); }
bool LocalTempCopyOfFile::IsFullyMessedUpString(CStdString sFileName) { CStdString sFileNameWithoutExtension = RemoveExtension(sFileName); CPINFO codepageInfo; ::GetCPInfo(CP_ACP, &codepageInfo); for(unsigned int i=0; i<sFileNameWithoutExtension.length(); i++) { if ( sFileNameWithoutExtension[i] != codepageInfo.DefaultChar[0]) return false; } return true; }
C4FileSelDlg::DefaultListItem::DefaultListItem(const char *szFilename, bool fTruncateExtension, bool fCheckbox, bool fGrayed, C4GUI::Icons eIcon) : C4FileSelDlg::ListItem(szFilename), pLbl(NULL), pCheck(NULL), pKeyCheck(NULL), fGrayed(fGrayed) { StdStrBuf sLabel; if (szFilename) sLabel.Ref(::GetFilename(szFilename)); else sLabel.Ref(LoadResStr("IDS_CTL_NONE")); if (szFilename && fTruncateExtension) { sLabel.Copy(); char *szFilename = sLabel.GrabPointer(); RemoveExtension(szFilename); sLabel.Take(szFilename); } rcBounds.Hgt = C4GUI::GetRes()->TextFont.GetLineHeight(); UpdateSize(); C4GUI::ComponentAligner caMain(GetContainedClientRect(), 0, 0); int32_t iHeight = caMain.GetInnerHeight(); if (fCheckbox) { pCheck = new C4GUI::CheckBox(caMain.GetFromLeft(iHeight), NULL, false); if (fGrayed) pCheck->SetEnabled(false); AddElement(pCheck); pKeyCheck = new C4KeyBinding( C4KeyCodeEx(K_SPACE), "FileSelToggleFileActive", KEYSCOPE_Gui, new C4GUI::ControlKeyCB<ListItem>(*this, &ListItem::UserToggleCheck), C4CustomKey::PRIO_Ctrl); } C4GUI::Icon *pIco = new C4GUI::Icon(caMain.GetFromLeft(iHeight), eIcon); AddElement(pIco); pLbl = new C4GUI::Label( sLabel.getData(), caMain.GetAll(), ALeft, fGrayed ? C4GUI_CheckboxDisabledFontClr : C4GUI_CheckboxFontClr); AddElement(pLbl); }
bool Platform::AddExtension(std::shared_ptr<gd::PlatformExtension> extension) { if (!extension) return false; std::cout << "Loading " << extension->GetName() << "..."; if (IsExtensionLoaded(extension->GetName())) { std::cout << " (replacing existing extension)"; RemoveExtension(extension->GetName()); } std::cout << std::endl; extensionsLoaded.push_back(extension); // Load all creation/destruction functions for objects provided by the // extension vector<gd::String> objectsTypes = extension->GetExtensionObjectsTypes(); for (std::size_t i = 0; i < objectsTypes.size(); ++i) { creationFunctionTable[objectsTypes[i]] = extension->GetObjectCreationFunctionPtr(objectsTypes[i]); } return true; }
void ProcessMolfileDirectory(string Directory,string OutputDirectory) { vector<string> DirectoryList = GetDirectoryFileList(Directory); Data* NewData = new Data(0); for (int i=0; i < int(DirectoryList.size()); i++) { cout << DirectoryList[i] << endl; Species* NewSpecies = new Species("", NewData, false); if (DirectoryList[i].length() > 0) { NewSpecies->ReadFromMol(Directory+DirectoryList[i]); NewSpecies->LabelAtoms(); string FileRoot = RemovePath(RemoveExtension(DirectoryList[i])); ofstream Output; if (OpenOutput(Output,OutputDirectory+FileRoot+".txt")) { Output << "Atom index;Group;GroupIndex" << endl; for (int j=0; j < NewSpecies->FNumAtoms(); j++) { Output << j << ";" << NewSpecies->GetAtom(j)->FGroupString() << ";" << NewSpecies->GetAtom(j)->FGroupIndex() << endl; } Output.close(); } } delete NewSpecies; } }
bool C4DefGraphics::Load(C4Group &hGroup, StdMeshSkeletonLoader &loader, bool fColorByOwner) { char Filename[_MAX_PATH+1]; *Filename=0; // load skeletons hGroup.ResetSearch(); while (hGroup.FindNextEntry("*", Filename, NULL, !!*Filename)) { if (!WildcardMatch(C4CFN_DefSkeleton, Filename) && !WildcardMatch(C4CFN_DefSkeletonXml, Filename)) continue; LoadSkeleton(hGroup, Filename, loader); } // Try from Mesh first if (!LoadMesh(hGroup, C4CFN_DefMesh, loader)) if(!LoadMesh(hGroup, C4CFN_DefMeshXml, loader)) LoadBitmap(hGroup, C4CFN_DefGraphics, C4CFN_ClrByOwner, C4CFN_NormalMap, fColorByOwner); // load additional graphics C4DefGraphics *pLastGraphics = this; const int32_t iOverlayWildcardPos = SCharPos('*', C4CFN_ClrByOwnerEx); hGroup.ResetSearch(); *Filename=0; const char* const AdditionalGraphics[] = { C4CFN_DefGraphicsEx, C4CFN_DefGraphicsExMesh, C4CFN_DefGraphicsExMeshXml, NULL }; while (hGroup.FindNextEntry("*", Filename, NULL, !!*Filename)) { for(const char* const* szWildcard = AdditionalGraphics; *szWildcard != NULL; ++szWildcard) { if(!WildcardMatch(*szWildcard, Filename)) continue; // skip def graphics if (SEqualNoCase(Filename, C4CFN_DefGraphics) || SEqualNoCase(Filename, C4CFN_DefMesh) || SEqualNoCase(Filename, C4CFN_DefMeshXml)) continue; // skip scaled def graphics if (WildcardMatch(C4CFN_DefGraphicsScaled, Filename)) continue; // get name char GrpName[_MAX_PATH+1]; const int32_t iWildcardPos = SCharPos('*', *szWildcard); SCopy(Filename + iWildcardPos, GrpName, _MAX_PATH); RemoveExtension(GrpName); // remove trailing number for scaled graphics int32_t extpos; int scale; if ((extpos = SCharLastPos('.', GrpName)) > -1) if (sscanf(GrpName+extpos+1, "%d", &scale) == 1) GrpName[extpos] = '\0'; // clip to max length GrpName[C4MaxName]=0; // create new graphics pLastGraphics->pNext = new C4AdditionalDefGraphics(pDef, GrpName); pLastGraphics = pLastGraphics->pNext; if(*szWildcard == AdditionalGraphics[0]) { // create overlay-filename char OverlayFn[_MAX_PATH+1]; if(fColorByOwner) { // GraphicsX.png -> OverlayX.png SCopy(C4CFN_ClrByOwnerEx, OverlayFn, _MAX_PATH); OverlayFn[iOverlayWildcardPos]=0; SAppend(Filename + iWildcardPos, OverlayFn); EnforceExtension(OverlayFn, GetExtension(C4CFN_ClrByOwnerEx)); } // create normal filename char NormalFn[_MAX_PATH+1]; SCopy(C4CFN_NormalMapEx, NormalFn, _MAX_PATH); NormalFn[iOverlayWildcardPos]=0; SAppend(Filename + iWildcardPos, NormalFn); EnforceExtension(NormalFn, GetExtension(C4CFN_NormalMapEx)); // load them if (!pLastGraphics->LoadBitmap(hGroup, Filename, fColorByOwner ? OverlayFn : NULL, NormalFn, fColorByOwner)) return false; } else { if (!pLastGraphics->LoadMesh(hGroup, Filename, loader)) return false; } } } // done, success return true; }
std::string ReplaceExtenstion(const std::string& path, const std::string& extension) { return RemoveExtension(path) + extension; }
// Load compressed MIN ROM static int PokeMini_iLoadROMZip(const char *zipfile, int *colorloaded) { unzFile uf = NULL; unz_global_info64 gi; unz_file_info64 file_inf; char filein[PMTMPV]; void *new_data; int i, size, loaded = 0, cloaded = 0; if (colorloaded) *colorloaded = 0; // Open ZIP uf = unzOpen(zipfile); if (!uf) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Opening ZIP error"); return 0; } if (unzGetGlobalInfo64(uf, &gi) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Getting global info"); unzClose(uf); return 0; } // Find and load MIN for (i=0; i<gi.number_entry; i++) { if (unzGetCurrentFileInfo64(uf, &file_inf, filein, PMTMPV, NULL, 0, NULL, 0) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Current file info"); unzClose(uf); return 0; } if (ExtensionCheck(filein, ".min") && (!loaded)) { if (unzLocateFile(uf, filein, 0) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "LocateFile failed"); unzClose(uf); return 0; } if (unzOpenCurrentFile(uf) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Opening file error"); unzClose(uf); return 0; } size = GetMultiple2(file_inf.uncompressed_size); new_data = (void *)malloc(size); memset(new_data, 0xFF, size); if (!new_data) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Not enough memory"); unzCloseCurrentFile(uf); unzClose(uf); return 0; } size = unzReadCurrentFile(uf, new_data, file_inf.uncompressed_size); if (size < 0) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Reading file error"); unzCloseCurrentFile(uf); unzClose(uf); return 0; } PokeMini_FreeColorInfo(); // Free existing color information PokeMini_SetMINMem((uint8_t *)new_data, file_inf.uncompressed_size); PM_ROM_Alloc = 1; if (unzCloseCurrentFile(uf) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Closing file error"); unzClose(uf); return 0; } if (PokeMini_OnAllocMIN) PokeMini_OnAllocMIN(PM_ROM_Size, 1); if (PokeMini_OnLoadMINFile) PokeMini_OnLoadMINFile(zipfile, 1); loaded = 1; break; } if ((i+1) < gi.number_entry) { if (unzGoToNextFile(uf) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "No next file"); unzClose(uf); return 0; } } } // Check if there's color information file strcat(filein, "c"); if (!loaded) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "No ROM in ZIP"); unzClose(uf); return 0; } else { if (unzGoToFirstFile(uf) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "No first file"); unzClose(uf); return 0; } if (unzLocateFile(uf, filein, 0) == UNZ_OK) { if (unzOpenCurrentFile(uf) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Opening file error"); unzClose(uf); return 0; } if (!PokeMini_LoadColorStream(PokeMini_StreamFromZIP, uf)) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Reading file error"); unzCloseCurrentFile(uf); unzClose(uf); return 0; } if (unzCloseCurrentFile(uf) != UNZ_OK) { if (PokeMini_OnUnzipError) PokeMini_OnUnzipError(zipfile, "Closing file error"); unzClose(uf); return 0; } cloaded = 1; if (colorloaded) *colorloaded = 1; if (PokeMini_OnLoadColorFile) PokeMini_OnLoadColorFile(zipfile, 1); } } // Close ZIP unzClose(uf); // Try to load color information from a file outside if wasn't found in the zip if (!cloaded) { // Filename based of the ROM inside the zip RemoveExtension(filein); strcat(filein, ".minc"); if (FileExist(filein)) { if (PokeMini_LoadColorFile(filein)) { if (colorloaded) *colorloaded = 1; if (PokeMini_OnLoadColorFile) PokeMini_OnLoadColorFile(zipfile, 1); return 1; } } // Filename based of the zip strcpy(filein, zipfile); RemoveExtension(filein); strcat(filein, ".minc"); if (FileExist(filein)) { if (PokeMini_LoadColorFile(filein)) { if (colorloaded) *colorloaded = 1; if (PokeMini_OnLoadColorFile) PokeMini_OnLoadColorFile(zipfile, 1); return 1; } } } return 1; }
//--------------------------------------------------------------------------- void TFormScoreTests::ReadFile(const String& filename) { const int row = StringGridStudents->RowCount - 1; const std::string file_stripped = RemoveExtension(RemovePath(filename.c_str())); ++StringGridStudents->RowCount; StringGridStudents->Cells[0][row] = row; StringGridStudents->Cells[1][row] = file_stripped.c_str(); StringGridStudents->Cells[2][row] = ""; StringGridStudents->Cells[3][row] = ""; const int key = EditKey->Text.ToInt(); const int penalty = EditPenalty->Text.ToInt(); const Encranger e(key); //Load file std::vector<std::string> v = FileToVector(filename.c_str()); const int sz = v.size(); for (int i=0; i!=sz; ++i) { //Deencrypt file v[i] = e.Deencrypt(v[i]); //Remove asterisks v[i] = ReplaceAll(v[i],"*",""); } const std::string username = FindUserName(v); if (username.empty()) { StringGridStudents->Cells[3][row] = "Username not found"; StringGridStudents->Cells[2][row] = "1.0 or 1.1"; return; } if (username != file_stripped) { StringGridStudents->Cells[3][row] = "Filename differs from username"; StringGridStudents->Cells[2][row] = "1.1"; return; } int n_correct = 0; const int n_questions = CountQuestions(v); LabelNquestions->Caption = "#questions: " + IntToStr(n_questions); for (int i=0; i!=sz; ++i) { if (v[i].empty()) continue; const std::vector<std::string> line_markup = SeperateString(v[i],","); //Replace {comma} by a comma for each std::string in v const std::vector<std::string> line = ReplaceAll(line_markup,"{comma}",","); OutputDebugString(line.size() >= 1 ? line[0].c_str() : "line[0] = {}"); OutputDebugString(line.size() >= 2 ? line[1].c_str() : "line[1] = {}"); OutputDebugString(line.size() >= 3 ? line[2].c_str() : "line[2] = {}"); OutputDebugString(line.size() >= 4 ? line[3].c_str() : "line[3] = {}"); //assert(line.size() == 2); WORKAROUND if (line[0]=="NAME") continue; const bool is_correct = (line[line.size()-1]=="Y"); //WORKAROUND assert(line[line.size()-1]=="Y" || line[line.size()-1]=="N"); //WORKAROUND if (is_correct) ++n_correct; ScoreQuestion(line[0],is_correct); } //Calculate student's score assert(n_questions - penalty > 0); const double fraction = static_cast<double>(n_correct - penalty) / static_cast<double>(n_questions - penalty); const double init_score = 1.0 + (9.0 * fraction); const double score_above_one = (init_score < 1.0 ? 1.0 : init_score); const double score_below_ten = (score_above_one > 10.0 ? 10.0 : score_above_one); const double score = score_below_ten; StringGridStudents->Cells[2][row] = score; }
std::string ribi::ndsm::Ndsmake::GetTarget() const noexcept { return m_pro_file.GetTarget().empty() ? RemoveExtension( this->m_pro_file.GetQtCreatorProFilename() ) : (*m_pro_file.GetTarget().begin()); }
bool C4ObjectInfo::Save(C4Group &hGroup, bool fStoreTiny, C4DefList *pDefs) { // Set group file name; rename if necessary char szTempGroup[_MAX_PATH+1]; SCopy(Name, szTempGroup, _MAX_PATH); MakeFilenameFromTitle(szTempGroup); SAppend(".oci",szTempGroup, _MAX_PATH); if (!SEqualNoCase(Filename, szTempGroup)) { if (!Filename[0]) { // first time creation of file - make sure it's not a duplicate SCopy(szTempGroup, Filename, _MAX_PATH); while (hGroup.FindEntry(Filename)) { // if a crew info of that name exists already, rename! RemoveExtension(Filename); int32_t iFinNum = GetTrailingNumber(Filename), iLen = SLen(Filename); while (iLen && Inside(Filename[iLen-1], '0', '9')) --iLen; if (iLen>_MAX_PATH-22) { LogF("Error generating unique filename for %s(%s): Path overflow", Name, hGroup.GetFullName().getData()); break; } snprintf(Filename+iLen, 22, "%d", iFinNum+1); EnforceExtension(Filename, "oci"); } } else { // Crew was renamed; file rename necessary, if the name is not blocked by another crew info if (!hGroup.FindEntry(szTempGroup)) { if (hGroup.Rename(Filename, szTempGroup)) SCopy(szTempGroup, Filename, _MAX_PATH); else { // could not rename. Not fatal; just use old file LogF("Error adjusting crew info for %s into %s: Rename error from %s to %s!", Name, hGroup.GetFullName().getData(), Filename, szTempGroup); } } } } // Open group C4Group hTemp; if (!hTemp.OpenAsChild(&hGroup, Filename, false, true)) return false; // custom rank image present? if (pDefs && !fStoreTiny) { C4Def *pDef = pDefs->ID2Def(id); if (pDef) { if (pDef->pRankSymbols) { C4FacetSurface fctRankSymbol; if (C4RankSystem::DrawRankSymbol(&fctRankSymbol, Rank, pDef->pRankSymbols, pDef->iNumRankSymbols, true)) { fctRankSymbol.GetFace().SavePNG(hTemp, C4CFN_ClonkRank); } } else { // definition does not have custom rank symbols: Remove any rank image from Clonk hTemp.Delete(C4CFN_ClonkRank); } } } // Save info to temp group if (!C4ObjectInfoCore::Save(hTemp, pDefs)) { hTemp.Close(); return false; } // Close temp group hTemp.Close(); // Success return true; }
// Returns only the filename without extension, i.e. will not include a path. std::wstring CPathUtils::GetFileNameWithoutExtension( const std::wstring& path ) { return RemoveExtension(GetFileName(path)); }
BOOL CFileUtil::FindFiles(const char*szInDirectory, BOOL bDirs, const char*szInName, const char*szExtension, CArrayChars* paszFiles, BOOL bHidden) { WIN32_FIND_DATA sFindData; CChars szFindName; CChars szTemp; HANDLE hFindHandle; BOOL bContinue; int iFileExtension; BOOL bValid; CChars szFake; CChars szDirectory; szDirectory.Init(szInDirectory); FullPath(&szDirectory); szFindName.Init(szDirectory); AppendToPath(&szFindName, "*.*"); hFindHandle = FindFirstFile(szFindName.Text(), &sFindData); bContinue = (hFindHandle != INVALID_HANDLE_VALUE); if (!bContinue) { szDirectory.Kill(); szFindName.Kill(); return FALSE; } while (bContinue) { if (!(sFindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) || bHidden) { bValid = TRUE; if (sFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (bDirs) { if (szInName != NULL) { szTemp.Init(sFindData.cFileName); RemoveExtension(&szTemp); if (!szTemp.ContainsIgnoreCase(szInName)) { bValid = FALSE; } szTemp.Kill(); } } else { bValid = FALSE; } } else { if (!bDirs) { if (szExtension != NULL) { szFake.Fake(sFindData.cFileName); iFileExtension = FindExtension(szFake.Text()); if (iFileExtension != -1) { if (!(szFake.SubStringEquals(iFileExtension+1, szExtension))) { bValid = FALSE; } } else { //If there is no file extension on the current file and the //extension being looked for is not empty... if (szExtension[0] != 0) { //Then this file is not valid. bValid = FALSE; } } } if (szInName != NULL) { szTemp.Init(sFindData.cFileName); RemoveExtension(&szTemp); if (!szTemp.ContainsIgnoreCase(szInName)) { bValid = FALSE; } szTemp.Kill(); } } else { bValid = FALSE; } } } else { bValid = FALSE; } if (bValid) { if (!((strcmp(sFindData.cFileName, ".") == 0) || (strcmp(sFindData.cFileName, "..") == 0))) { szTemp.Init(szDirectory); AppendToPath(&szTemp, sFindData.cFileName); paszFiles->Add(szTemp.Text()); szTemp.Kill(); } } bContinue = FindNextFile(hFindHandle, &sFindData); } FindClose(hFindHandle); szDirectory.Kill(); szFindName.Kill(); return TRUE; }
void LoadDatabaseFile(const char* DatabaseFilename) { if (GetParameter("Network output location").compare("none") != 0 && GetParameter("Network output location").length() > 0) { if (GetParameter("os").compare("windows") == 0) { system(("move "+GetDatabaseDirectory(GetParameter("database"),"output directory")+GetParameter("output folder")+" "+GetParameter("Network output location")).data()); } else { system(("cp -r "+GetDatabaseDirectory(GetParameter("database"),"output directory")+GetParameter("output folder")+" "+GetParameter("Network output location")).data()); } } //Getting filename that all compound and reaction data will be saved into string Filename(DatabaseFilename); if (Filename.length() == 0) { Filename = AskString("Input filename for database: "); } //Creating datastructure for all program data Data* NewData = new Data(0); NewData->ClearData("NAME",STRING); NewData->AddData("NAME",RemoveExtension(RemovePath(Filename)).data(),STRING); //Loading data from file if (NewData->LoadSystem(Filename) == FAIL) { delete NewData; return; } //Performing a variety of tasks according to the parameters in the parameters files including KEGG lookup, reaction and compound printing etc. NewData->PerformAllRequestedTasks(); // Test for Adjustment of DeltaGs for PH for COMPOUNDS bool TestCpds = 0; if (TestCpds){ double IonicS = 0.25; FErrorFile() << "Std Transformed Gibbs Energy of Formation vs pH" << endl; for (int i=0; i < NewData->FNumSpecies(); i++){ string CompoundID = NewData->GetSpecies(i)->GetData("DATABASE",STRING); // gets the cpdID string Name = NewData->GetSpecies(i)->GetData("NAME",STRING); // gets the name of the cpd Species* Temp = NewData->FindSpecies("DATABASE",CompoundID.data()); //if (CompoundID.compare("cpd00003") == 0 || CompoundID.compare("cpd00004") == 0 || CompoundID.compare("cpd00002") == 0) { double AdjDeltaG5 = Temp->AdjustedDeltaG(IonicS,5,298.15); double AdjDeltaG5_kJ = 4.184*AdjDeltaG5; double AdjDeltaG6 = Temp->AdjustedDeltaG(IonicS,6,298.15); double AdjDeltaG6_kJ = 4.184*AdjDeltaG6; double AdjDeltaG7 = Temp->AdjustedDeltaG(IonicS,7,298.15); double AdjDeltaG7_kJ = 4.184*AdjDeltaG7; double AdjDeltaG8 = Temp->AdjustedDeltaG(IonicS,8,298.15); double AdjDeltaG8_kJ = 4.184*AdjDeltaG8; double AdjDeltaG9 = Temp->AdjustedDeltaG(IonicS,9,298.15); double AdjDeltaG9_kJ = 4.184*AdjDeltaG9; FErrorFile() << CompoundID << "\t" << AdjDeltaG5_kJ << "\t" << AdjDeltaG6_kJ << "\t" << AdjDeltaG7_kJ << "\t" << AdjDeltaG8_kJ << "\t" << AdjDeltaG9_kJ << endl; //} } FlushErrorFile(); } // Test for Adjustment of DeltaGs for IONIC STRENGTH for COMPOUNDS bool TestCpdsIS = 0; if (TestCpdsIS){ FErrorFile() << "Std Transformed Gibbs Energy of Formation vs Ionic Strength" << endl; for (int i=0; i < NewData->FNumSpecies(); i++){ string CompoundID = NewData->GetSpecies(i)->GetData("DATABASE",STRING); // gets the cpdID string Name = NewData->GetSpecies(i)->GetData("NAME",STRING); // gets the name of the cpd Species* Temp = NewData->FindSpecies("DATABASE",CompoundID.data()); double AdjDeltaG_IS0 = Temp->AdjustedDeltaG(0,7,298.15); double AdjDeltaG_IS0_kJ = 4.184*AdjDeltaG_IS0; double AdjDeltaG_IS10 = Temp->AdjustedDeltaG(0.1,7,298.15); double AdjDeltaG_IS10_kJ = 4.184*AdjDeltaG_IS10; double AdjDeltaG_IS25 = Temp->AdjustedDeltaG(0.25,7,298.15); double AdjDeltaG_IS25_kJ = 4.184*AdjDeltaG_IS25; FErrorFile() << CompoundID << "\t" << AdjDeltaG_IS0_kJ << "\t" << AdjDeltaG_IS10_kJ << "\t" << AdjDeltaG_IS25_kJ << endl; } FlushErrorFile(); } // Test for Adjustment of DeltaGs for pH for REACTIONS bool TestRxns = 0; if (TestRxns){ double IonicS = 0.25; //double pH = 7; FErrorFile() << "Std Transformed Gibbs Energy of Reaction (kJmol-1) vs pH" << endl; for (int i=0; i < NewData->FNumReactions(); i++){ Reaction* Rxn = NewData->GetReaction(i); string RxnID = Rxn->GetData("DATABASE",STRING); string Name = Rxn->GetData("NAME",STRING); double DG5 = Rxn->FEstDeltaG(5,IonicS)*4.184; double DG6 = Rxn->FEstDeltaG(6,IonicS)*4.184; double DG7 = Rxn->FEstDeltaG(7,IonicS)*4.184; double DG8 = Rxn->FEstDeltaG(8,IonicS)*4.184; double DG9 = Rxn->FEstDeltaG(9,IonicS)*4.184; FErrorFile() << RxnID << "\t" << DG5 << "\t" << DG6 << "\t" << DG7 << "\t" << DG8 << "\t" << DG9 << endl; } FlushErrorFile(); } // Test for Adjustment of DeltaGs for IONIC STRENGTH for REACTIONS bool TestRxnsIS = 0; if (TestRxnsIS){ FErrorFile() << "Std Transformed Gibbs Energy of Reaction (kJmol-1) vs Ionic Strength" << endl; for (int i=0; i < NewData->FNumReactions(); i++){ Reaction* Rxn = NewData->GetReaction(i); string RxnID = Rxn->GetData("DATABASE",STRING); string Name = Rxn->GetData("NAME",STRING); double DG_IS0 = Rxn->FEstDeltaG(7,0.25)*4.184; double DG_IS10 = Rxn->FEstDeltaG(7,0.15)*4.184; double DG_IS25 = Rxn->FEstDeltaG(7,0.25)*4.184; FErrorFile() << RxnID << "\t" << DG_IS0 << "\t" << DG_IS10 << "\t" << DG_IS25 << endl; } // FlushErrorFile(); } delete NewData; };
//////////////////////////////////////////////////////////////////////// // Main prefilter function //////////////////////////////////////////////////////////////////////// void Prefilter::prefilter_db(HMM* q_tmp, Hash<Hit>* previous_hits, const int threads, const int prefilter_gap_open, const int prefilter_gap_extend, const int prefilter_score_offset, const int prefilter_bit_factor, const double prefilter_evalue_thresh, const double prefilter_evalue_coarse_thresh, const int preprefilter_smax_thresh, const int min_prefilter_hits, const int maxnumdb, const float R[20][20], std::vector<std::pair<int, std::string> >& new_prefilter_hits, std::vector<std::pair<int, std::string> >& old_prefilter_hits) { Hash<char>* doubled = new Hash<char>; doubled->New(16381, 0); int element_count = (VECSIZE_INT * 4); //W = (LQ+15) / 16; // band width = hochgerundetes LQ/16 int W = (q_tmp->L + (element_count - 1)) / element_count; // query profile (states + 1 because of ANY char) unsigned char* qc = (unsigned char*)malloc_simd_int((hh::NUMCOLSTATES+1)*(q_tmp->L+element_count)*sizeof(unsigned char)); stripe_query_profile(q_tmp, prefilter_score_offset, prefilter_bit_factor, W, qc); simd_int ** workspace = new simd_int *[threads]; std::vector<std::pair<int, int> > first_prefilter; std::vector<std::pair<double, int> > hits; int count_dbs = 0; int gap_init = prefilter_gap_open + prefilter_gap_extend; int gap_extend = prefilter_gap_extend; int LQ = q_tmp->L; const float log_qlen = flog2(LQ); const double factor = (double) num_dbs * LQ; for (int i = 0; i < threads; i++) workspace[i] = (simd_int*) malloc_simd_int( 3 * (LQ + element_count) * sizeof(char)); #pragma omp parallel for schedule(static) // Loop over all database sequences for (size_t n = 0; n < num_dbs; n++) { int thread_id = 0; #ifdef OPENMP thread_id = omp_get_thread_num(); #endif // Perform search step int score = ungapped_sse_score(qc, LQ, first[n], length[n], prefilter_score_offset, workspace[thread_id]); score = score - (int) (prefilter_bit_factor * (log_qlen + flog2(length[n]))); #pragma omp critical first_prefilter.push_back(std::pair<int, int>(score, n)); } //filter after calculation of ungapped sse score to include at least min_prefilter_hits std::vector<std::pair<int, int> >::iterator it; sort(first_prefilter.begin(), first_prefilter.end()); std::reverse(first_prefilter.begin(), first_prefilter.end()); std::vector<std::pair<int, int> >::iterator first_prefilter_begin_erase = first_prefilter.end(); std::vector<std::pair<int, int> >::iterator first_prefilter_end_erase = first_prefilter.end(); count_dbs = 0; for (it = first_prefilter.begin(); it < first_prefilter.end(); it++) { if (count_dbs >= min_prefilter_hits && (*it).first <= preprefilter_smax_thresh) { first_prefilter_begin_erase = it; break; } else { count_dbs++; } } first_prefilter.erase(first_prefilter_begin_erase, first_prefilter_end_erase); HH_LOG(INFO) << "HMMs passed 1st prefilter (gapless profile-profile alignment) : " << count_dbs << std::endl; #pragma omp parallel for schedule(static) // Loop over all database sequences // for (int n = 0; n < count_dbs; n++) { for (size_t i = 0; i < first_prefilter.size(); i++) { int thread_id = 0; #ifdef OPENMP thread_id = omp_get_thread_num(); #endif int n = first_prefilter[i].second; // Perform search step int score = swStripedByte(qc, LQ, first[n], length[n], gap_init, gap_extend, workspace[thread_id], workspace[thread_id] + W, workspace[thread_id] + 2 * W, prefilter_score_offset); double evalue = factor * length[n] * fpow2(-score / prefilter_bit_factor); if (evalue < prefilter_evalue_coarse_thresh) { #pragma omp critical hits.push_back(std::pair<double, int>(evalue, n)); } } //filter after calculation of evalues to include at least min_prefilter_hits sort(hits.begin(), hits.end()); std::vector<std::pair<double, int> >::iterator second_prefilter_begin_erase = hits.end(); std::vector<std::pair<double, int> >::iterator second_prefilter_end_erase = hits.end(); std::vector<std::pair<double, int> >::iterator it2; count_dbs = 0; for (it2 = hits.begin(); it2 < hits.end(); it2++) { if (count_dbs >= min_prefilter_hits && (*it2).first > prefilter_evalue_thresh) { second_prefilter_begin_erase = it2; break; } else { count_dbs++; } } hits.erase(second_prefilter_begin_erase, second_prefilter_end_erase); count_dbs = 0; for (it2 = hits.begin(); it2 < hits.end(); it2++) { // Add hit to dbfiles count_dbs++; char db_name[NAMELEN]; strcpy(db_name, dbnames[(*it2).second]); char name[NAMELEN]; RemoveExtension(name, db_name); if (!doubled->Contains(db_name)) { doubled->Add(db_name); std::pair<int, std::string> result; result.first = length[(*it2).second]; result.second = std::string(db_name); // check, if DB was searched in previous rounds strcat(name, "__1"); // irep=1 if (previous_hits->Contains(name)) { old_prefilter_hits.push_back(result); } else { new_prefilter_hits.push_back(result); } } if (count_dbs >= maxnumdb) { HH_LOG(WARNING) << "Number of hits passing 2nd prefilter (reduced from " << hits.size() << " to allowed maximum of " << maxnumdb << ").\n" <<"You can increase the allowed maximum using the -maxfilt <max> option.\n"; break; } } // Free memory free(qc); for (int i = 0; i < threads; i++) free(workspace[i]); delete[] workspace; if (doubled) delete doubled; }
void C4ConsoleQtDefinitionListModel::ReInit() { // Re-fill definition model with all loaded definitions matching condition // (TODO: Add conditional lists) root = std::make_unique<C4ConsoleQtDefinitionListModel::DefListNode>(); int32_t index = 0; C4Def *def; while ((def = ::Definitions.GetDef(index++))) { // Ignore hidden defs if (def->HideInCreator) continue; // Build path leading to this definition DefListNode *node_parent = root.get(); StdCopyStrBuf fn(def->Filename), fn2; StdCopyStrBuf fn_full; fn.ReplaceChar(AltDirectorySeparator, DirectorySeparator); for (;;) { bool is_parent_folder = fn.SplitAtChar(DirectorySeparator, &fn2); if (fn_full.getLength()) { fn_full.AppendChar(DirectorySeparator); } fn_full.Append(fn); if (!is_parent_folder || WildcardMatch(C4CFN_DefFiles, fn.getData())) // ignore non-.ocd-folders (except for final definition) { // Find if path is already there RemoveExtension(&fn); DefListNode *node_child = nullptr; for (auto &test_node_child : node_parent->items) if (test_node_child->filename == fn) { node_child = &*test_node_child; break; } // If not, create it if (!node_child) { node_parent->items.emplace_back((node_child = new DefListNode())); node_child->idx = node_parent->items.size() - 1; node_child->parent = node_parent; const char *localized_name = ::Definitions.GetLocalizedGroupFolderName(fn_full.getData()); node_child->name.Copy(localized_name ? localized_name : fn.getData()); node_child->filename.Copy(fn); } // And fill in node if this is not a parent folder if (!is_parent_folder) { node_child->def = def; const char *def_name = def->GetName(); if (def_name && *def_name) node_child->name.Copy(def_name); break; } else { // Parent folder: Next path segment node_parent = node_child; } } fn = fn2; } } // Descend into singleton root classes. I.e. if all elements are children of Objects/Items, move the root in there. DefListNode *new_root = root.get(); while (new_root->items.size() == 1 && !new_root->items[0]->def) { std::unique_ptr<DefListNode> tmp(new_root->items[0].release()); root.reset(tmp.release()); new_root = root.get(); } root->parent = nullptr; // Copy group path names into definitions for later lookup by script QStringList group_names; DefListNode *node = root.get(); while (node) { if (node->def) { node->def->ConsoleGroupPath.Copy(group_names.join('/').toUtf8()); } // Walk over tree. Remember groups in group_names string list. if (!node->items.empty()) { if (node != root.get()) group_names.append(node->name.getData()); node = node->items[0].get(); } else { int32_t idx = node->idx + 1; while ((node = node->parent)) { if (node->items.size() > idx) { node = node->items[idx].get(); break; } if (group_names.size()) group_names.pop_back(); idx = node->idx + 1; } } } // Sort everything by display name (recursively) root->SortByName(); // Model reset to invalidate all indexes beginResetModel(); endResetModel(); }
///////////////////////////////////////////////////////////////////////////////////// //// MAIN PROGRAM ///////////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { char* argv_conf[MAXOPT]; // Input arguments from .hhdefaults file (first=1: argv_conf[0] is not used) int argc_conf; // Number of arguments in argv_conf strcpy(par.infile, ""); strcpy(par.outfile, ""); strcpy(par.alnfile, ""); //Default parameter settings par.nseqdis = MAXSEQ - 1; // maximum number of sequences to be written par.showcons = 0; par.cons = 1; par.Ndiff = 0; par.max_seqid = 100; par.coverage = 0; par.pc_hhm_context_engine.pca = 0.0; // no amino acid pseudocounts par.pc_hhm_nocontext_a = 0.0; // no amino acid pseudocounts par.gapb = 0.0; // no transition pseudocounts // Make command line input globally available par.argv = argv; par.argc = argc; RemovePathAndExtension(program_name, argv[0]); // Enable changing verbose mode before defaults file and command line are processed int v = 2; for (int i = 1; i < argc; i++) { if (!strcmp(argv[i], "-def")) par.readdefaultsfile = 1; else if (strcmp(argv[i], "-v") == 0) { v = atoi(argv[i + 1]); } } par.v = Log::from_int(v); Log::reporting_level() = par.v; par.SetDefaultPaths(); // Read .hhdefaults file? if (par.readdefaultsfile) { // Process default otpions from .hhconfig file ReadDefaultsFile(argc_conf, argv_conf); ProcessArguments(argc_conf, argv_conf); } // Process command line options (they override defaults from .hhdefaults file) ProcessArguments(argc, argv); Alignment* qali = new Alignment(MAXSEQ, par.maxres); HMM* q = new HMM(MAXSEQDIS, par.maxres); //Create a HMM with maximum of par.maxres match states // q is only available after maxres is known, so we had to move this here for (int i = 1; i <= argc - 1; i++) { if (!strcmp(argv[i], "-name") && (i < argc - 1)) { strmcpy(q->name, argv[++i], NAMELEN - 1); //copy longname to name... strmcpy(q->longname, argv[i], DESCLEN - 1); //copy full name to longname } } // Check command line input and default values if (!*par.infile) { help(); HH_LOG(ERROR) << "Input file is missing!" << std::endl; exit(4); } // Get basename RemoveExtension(q->file, par.infile); //Get basename of infile (w/o extension): // Outfile not given? Name it basename.hhm if (!*par.outfile && !*par.alnfile) { RemoveExtension(par.outfile, par.infile); strcat(par.outfile, ".seq"); } // Prepare CS pseudocounts lib if (!par.nocontxt && *par.clusterfile) { InitializePseudocountsEngine(par, context_lib, crf, pc_hhm_context_engine, pc_hhm_context_mode, pc_prefilter_context_engine, pc_prefilter_context_mode); } // Set substitution matrix; adjust to query aa distribution if par.pcm==3 SetSubstitutionMatrix(par.matrix, pb, P, R, S, Sim); // Read input file (HMM, HHM, or alignment format), and add pseudocounts etc. char input_format = 0; ReadQueryFile(par, par.infile, input_format, par.wg, q, qali, pb, S, Sim); // Same code as in PrepareQueryHMM(par.infile,input_format,q,qali), except that we add SS prediction // Add Pseudocounts, if no HMMER input if (input_format == 0) { // Transform transition freqs to lin space if not already done q->AddTransitionPseudocounts(par.gapd, par.gape, par.gapf, par.gapg, par.gaph, par.gapi, par.gapb, par.gapb); // Comput substitution matrix pseudocounts if (par.nocontxt) { // Generate an amino acid frequency matrix from f[i][a] with full pseudocount admixture (tau=1) -> g[i][a] q->PreparePseudocounts(R); // Add amino acid pseudocounts to query: p[i][a] = (1-tau)*f[i][a] + tau*g[i][a] q->AddAminoAcidPseudocounts(par.pc_hhm_nocontext_mode, par.pc_hhm_nocontext_a, par.pc_hhm_nocontext_b, par.pc_hhm_nocontext_c); } else { // Add full context specific pseudocounts to query q->AddContextSpecificPseudocounts(pc_hhm_context_engine, pc_hhm_context_mode); } } else { q->AddAminoAcidPseudocounts(0, par.pc_hhm_nocontext_a, par.pc_hhm_nocontext_b, par.pc_hhm_nocontext_c); } q->CalculateAminoAcidBackground(pb); if (par.columnscore == 5 && !q->divided_by_local_bg_freqs) q->DivideBySqrtOfLocalBackgroundFreqs( par.half_window_size_local_aa_bg_freqs, pb); // Write consensus sequence to sequence file // Consensus sequence is calculated in hhalignment.C, Alignment::FrequenciesAndTransitions() if (*par.outfile) { FILE* outf = NULL; if (strcmp(par.outfile, "stdout")) { outf = fopen(par.outfile, "a"); if (!outf) OpenFileError(par.outfile, __FILE__, __LINE__, __func__); } else outf = stdout; // OLD //// ">name_consensus" -> ">name consensus" //strsubst(q->sname[q->nfirst],"_consensus"," consensus"); //fprintf(outf,">%s\n%s\n",q->sname[q->nfirst],q->seq[q->nfirst]+1); // NEW (long header needed for NR30cons database) fprintf(outf, ">%s\n%s\n", q->longname, q->seq[q->nfirst] + 1); fclose(outf); } // Print A3M/A2M/FASTA output alignment if (*par.alnfile) { HalfAlignment qa; int n = imin(q->n_display, par.nseqdis + (q->nss_dssp >= 0) + (q->nss_pred >= 0) + (q->nss_conf >= 0) + (q->ncons >= 0)); qa.Set(q->name, q->seq, q->sname, n, q->L, q->nss_dssp, q->nss_pred, q->nss_conf, q->nsa_dssp, q->ncons); if (par.outformat == 1) qa.BuildFASTA(); else if (par.outformat == 2) qa.BuildA2M(); else if (par.outformat == 3) qa.BuildA3M(); if (qali->readCommentLine) qa.Print(par.alnfile, par.append, qali->longname); // print alignment to outfile else qa.Print(par.alnfile, par.append); // print alignment to outfile } delete qali; delete q; DeletePseudocountsEngine(context_lib, crf, pc_hhm_context_engine, pc_hhm_context_mode, pc_prefilter_context_engine, pc_prefilter_context_mode); }
bool C4MainMenu::ActivateSavegame(int32_t iPlayer) { // Check if saving is possible if (!Game.CanQuickSave()) return false; // Menu symbol/init char DirPath[_MAX_PATH+1]; char ScenName[_MAX_PATH+1]; *ScenName=0; InitRefSym(GfxR->fctMenu.GetPhase(0), LoadResStr("IDS_MENU_CPSAVEGAME"), iPlayer); SetAlignment(C4MN_Align_Left | C4MN_Align_Bottom); SetPermanent(true); // target file name mask // get folder & filename to store in // some magic is needed to ensure savegames are stored properly into their folders SCopy(GetFilename(Game.ScenarioFilename), DirPath); if (DirPath[strlen(DirPath) - 1] == '\\') DirPath[strlen(DirPath) - 1] = 0; RemoveExtension(DirPath); if (LooksLikeInteger(DirPath)) { // ScenTitle.ocf\%d.ocs-names (old-style savegames) // get owning folder if (Game.pParentGroup) { // owning folder determines filename SCopy(GetFilenameOnly(Game.pParentGroup->GetName()), ScenName); } else { // no owning folder known: too bad // make a vague guess based on the scenario title SCopy(GetFilenameOnly(Game.ScenarioFilename), ScenName); } } else { // DirPath is a valid filename for now... SCopy(DirPath, ScenName); // but remove trailing numbers to adjust new-style savegames char *pScenNameEnd = ScenName+SLen(ScenName); while (Inside<char>(*--pScenNameEnd, '0', '9')) if (pScenNameEnd == ScenName) { // should not happen: digit-only-filenames should have been caught earlier SCopy("dbg_error!", ScenName); pScenNameEnd = ScenName+SLen(ScenName)-1; } pScenNameEnd[1]=0; } // New Style 2007: // * scenarios are saved into ScenName.ocf/ScenName123.ocs to keep umlauts out of filenames // * language titles are stored in folders as title component StdStrBuf strFilename, strTitle; strFilename.Format("%s.ocf%c%s%%d.ocs", ScenName, DirectorySeparator, ScenName); strTitle = Game.ScenarioTitle; // Create menu items StdStrBuf strFilenameIndexed, strCommand, strCaption, strSavePath; for (int32_t i = 1; i <= 10; i++) { // Index filename strFilenameIndexed.Format(strFilename.getData(), i); // Compose commmand strCommand.Format("Save:Game:%s:%s", strFilenameIndexed.getData(), strTitle.getData()); // Notice: the language title might contain ':' and thus confuse the segment list - but C4Menu::MenuCommand will try to handle this... // Check free slot strSavePath.Format("%s%c%s", Config.AtUserDataPath(C4CFN_Savegames), DirectorySeparator, strFilenameIndexed.getData()); bool fFree = !C4Group_IsGroup(strSavePath.getData()); // Item caption strCaption = LoadResStr("IDS_MENU_CPSAVEGAME"); // add menu item AddRefSym(strCaption.getData(), GfxR->fctMenu.GetPhase(i - 1, fFree ? 2 : 1), strCommand.getData(), C4MN_Item_NoCount, NULL, LoadResStr("IDS_MENU_CPSAVEGAMEINFO")); } // Go back to options menu on close SetCloseCommand("ActivateMenu:Main"); return true; }
TRISTATE CFileFinder::FindFiles(char* szInDirectory, BOOL bDirs, char* szInName, char* szExtension) { DIR* pDIR; struct dirent* pDirEnt; char szFindName[MAX_PATH]; char szTemp[MAX_PATH]; BOOL bValid; char szDirectory[MAX_PATH]; char szFile[MAX_PATH]; char* szFileExtension; int iStatus; struct stat sBuffer; BOOL bDir; CFileUtil cFileUtil; if (!cFileUtil.FullPath(szDirectory, szInDirectory, MAX_PATH)) { return TRIERROR; } pDIR = opendir(szDirectory); if (pDIR == NULL) { return TRITRUE; } pDirEnt = readdir(pDIR); while (pDirEnt != NULL) { bValid = TRUE; sprintf(szTemp, "%s%s%s", szDirectory, FILE_SEPARATOR, pDirEnt->d_name); iStatus = stat(szTemp, &sBuffer); if (iStatus == -1) { printf("%s: %s\n", strerror(errno), szTemp); return TRIERROR; } bDir = S_ISDIR(sBuffer.st_mode); if (bDir) //Directory { if (bDirs) { if (szInName != NULL) { strcpy(szFile, pDirEnt->d_name); RemoveExtension(szFile); if (StrIStr(szFile, szInName) == NULL) { bValid = FALSE; } } else { bValid = FALSE; } } } else { if (!bDirs) { if (szExtension != NULL) { szFileExtension = FindExtension(pDirEnt->d_name); szFileExtension++; if (StrICmp(szFileExtension, szExtension) != 0) { bValid = FALSE; } } if (szInName != NULL) { strcpy(szFile, pDirEnt->d_name); RemoveExtension(szFile); if (StrIStr(szFile, szInName) == NULL) { bValid = FALSE; } } } else { bValid = FALSE; } } if (bValid) { mcFiles.Add(szTemp, 0); } pDirEnt = readdir(pDIR); } closedir(pDIR); return TRITRUE; }
void GetFileNameNoExtension(char* Result, const char* Path) { const char* FileName = GetFileName(Path); RemoveExtension(Result, FileName); }