bool D3MFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const { const std::string extension = GetExtension(pFile); if(extension == "3mf") { return true; } else if(!extension.length() || checkSig) { if(!pIOHandler) return true; } return false; }
//================================================================ // Name: Write // Class: DocFileOutput // // Description: Writes the file to disk // // Parameters: char *filename -- the filename to create // // Returns: None // //================================================================ void DocFileOutput::Write(const char *filename, ClassDef *classlist, int ptypeFlag) { char realname[255]; sprintf(realname,"%s.%s",filename,GetExtension()); fileptr = fopen(realname,"w"); if ( !fileptr ) return; // Store the type flag privately so we don't have to pass it around typeFlag = ptypeFlag; // Start the writing process OutputClasses(classlist); fclose(fileptr); }
void CAAudioFileFormats::FileFormatInfo::DebugPrint() { char ftype[20]; char ftypename[64]; CFStringGetCString(mFileTypeName, ftypename, sizeof(ftypename), kCFStringEncodingUTF8); printf("File type: '%s' = %s\n Extensions:", OSTypeToStr(ftype, mFileTypeID), ftypename); int i, n = NumberOfExtensions(); for (i = 0; i < n; ++i) { GetExtension(i, ftype, sizeof(ftype)); printf(" .%s", ftype); } LoadDataFormats(); printf("\n Formats:\n"); for (i = 0; i < mNumDataFormats; ++i) mDataFormats[i].DebugPrint(); }
void CDesignCollection::SelectAdventure (DWORD dwUNID) // SelectAdventure // // Enable the given adventure and disable all other adventures { int i; for (i = 0; i < GetExtensionCount(); i++) { SExtensionDesc *pEntry = GetExtension(i); if (pEntry->iType == extAdventure) pEntry->bEnabled = (pEntry->dwUNID == dwUNID); } }
int CExtensionListControl::CListItem::Compare(const CSortingListItem *baseOther, int subitem) const { int r = 0; const CListItem *other = (const CListItem *)baseOther; switch (subitem) { case COL_EXTENSION: { r = signum(GetExtension().CompareNoCase(other->GetExtension())); } break; case COL_COLOR: case COL_BYTES: { r = signum(m_record.bytes - other->m_record.bytes); } break; case COL_FILES: { r = signum(m_record.files - other->m_record.files); } break; case COL_DESCRIPTION: { r = signum(GetDescription().CompareNoCase(other->GetDescription())); } break; case COL_BYTESPERCENT: { r = signum(GetBytesFraction() - other->GetBytesFraction()); } break; default: { ASSERT(0); } } return r; }
bool HasExtension(const bfs::path& path) { // not sure this gives the same results as below // because the "." will be included in the extension // meaning that this may return true for a path that // is simply has an empty extension // see link for more information: // http://www.boost.org/doc/libs/1_49_0/libs/filesystem/v3/doc/reference.html#path-extension //return path.has_extension(); std::string extension = GetExtension(path); if (extension.empty() || extension == ".") { return false; } else { return true; } }
wxSize Image::ToImageFile(wxString filename) { wxFileName fn(filename); wxString ext = fn.GetExt(); if(filename.Lower().EndsWith(GetExtension().Lower())) { wxFile file(filename,wxFile::write); if(!file.IsOpened()) return wxSize(-1,-1); file.Write(m_compressedImage.GetData(), m_compressedImage.GetDataLen()); if(file.Close()) return wxSize(m_originalWidth,m_originalHeight); else return wxSize(-1,-1); } else { wxBitmap bitmap = GetUnscaledBitmap(); wxImage image=bitmap.ConvertToImage(); wxBitmapType mimetype = wxBITMAP_TYPE_ANY; if((ext.Lower() == wxT("jpg")) || (ext.Lower() == wxT("jpeg"))) mimetype = wxBITMAP_TYPE_JPEG; else if(ext.Lower() == wxT("png")) mimetype = wxBITMAP_TYPE_PNG; else if(ext.Lower() == wxT("pcx")) mimetype = wxBITMAP_TYPE_PCX; else if(ext.Lower() == wxT("pnm")) mimetype = wxBITMAP_TYPE_PNM; else if((ext.Lower() == wxT("tif")) || (ext.Lower() == wxT("tiff"))) mimetype = wxBITMAP_TYPE_TIFF; else if(ext.Lower() == wxT("xpm")) mimetype = wxBITMAP_TYPE_XPM; else if(ext.Lower() == wxT("ico")) mimetype = wxBITMAP_TYPE_ICO; else if(ext.Lower() == wxT("cur")) mimetype = wxBITMAP_TYPE_CUR; else return(wxSize(-1,-1)); if(!image.SaveFile(filename,mimetype)) return wxSize(-1,-1); return image.GetSize(); } }
RETCODE World::EntityLoad_Trigger(hQBSP qbsp, const EntityParse & entityDat) { //create new trigger Trigger *newObj = new Trigger; assert(newObj); /////////////////////////////////////////////////////// //load up the common stuff EntityLoad_CommonObject(qbsp, entityDat, dynamic_cast<Object *>(newObj)); const char *pStr; int iVal; /////////////////////////////////////////////////////// //can it only be turned on once? pStr = entityDat.GetVal("bOnce"); if(pStr) sscanf(pStr, "%d", &iVal); else iVal = 0; newObj->SetFlag(OBJ_FLAG_ONCE_ONLY, iVal ? true : false); //get script file char scriptPath[MAXCHARBUFF]; strcpy(scriptPath, m_filePath.c_str()); strcpy(GetExtension(scriptPath), SCENE_EXT); /////////////////////////////////////////////////////// //check if we want multiple entities to activate the trigger pStr = entityDat.GetVal("bAllowMultiple"); if(pStr) { sscanf(pStr, "%d", &iVal); newObj->AllowMultipleEntities(iVal == 1 ? true : false); } /////////////////////////////////////////////////////// //set the script for 'on' pStr = entityDat.GetVal("script"); if(pStr) newObj->LoadScript(scriptPath, pStr); return RETCODE_SUCCESS; }
RageSurface *RageSurfaceUtils::LoadFile( const RString &sPath, RString &error, bool bHeaderOnly ) { { RageFile TestOpen; if( !TestOpen.Open( sPath ) ) { error = TestOpen.GetError(); return NULL; } } set<RString> FileTypes; vector<RString> const& exts= ActorUtil::GetTypeExtensionList(FT_Bitmap); for(vector<RString>::const_iterator curr= exts.begin(); curr != exts.end(); ++curr) { FileTypes.insert(*curr); } RString format = GetExtension(sPath); format.MakeLower(); bool bKeepTrying = true; /* If the extension matches a format, try that first. */ if( FileTypes.find(format) != FileTypes.end() ) { RageSurface *ret = TryOpenFile( sPath, bHeaderOnly, error, format, bKeepTrying ); if( ret ) return ret; FileTypes.erase( format ); } for( set<RString>::iterator it = FileTypes.begin(); bKeepTrying && it != FileTypes.end(); ++it ) { RageSurface *ret = TryOpenFile( sPath, bHeaderOnly, error, *it, bKeepTrying ); if( ret ) { LOG->UserLog( "Graphic file", sPath, "is really %s", it->c_str() ); return ret; } } return NULL; }
void CDesignCollection::GetEnabledExtensions (TArray<CExtension *> *retExtensionList) // GetEnabledExtensions // // Returns the list of enabled extensions { int i; retExtensionList->DeleteAll(); for (i = 0; i < GetExtensionCount(); i++) { CExtension *pEntry = GetExtension(i); if (pEntry->GetType() == extExtension) retExtensionList->Insert(pEntry); } }
void CDesignCollection::GetEnabledExtensions (TArray<DWORD> *retExtensionList) // GetEnabledExtensions // // Returns the list of enabled extensions { int i; retExtensionList->DeleteAll(); for (i = 0; i < GetExtensionCount(); i++) { SExtensionDesc *pEntry = GetExtension(i); if (pEntry->iType == extExtension && pEntry->bEnabled) retExtensionList->Insert(pEntry->dwUNID); } }
BOOL CImage::ReadFile(const CString& fileName, int imageType) { int oldImageType = filetype; filename = fileName; if (imageType==-1) { imageType = search_formats(GetExtension((char *)(const char *)filename)); } filetype = imageType; if (!implementation || (imageType != oldImageType)) { if (!CreateImplementation(filename, imageType)) return FALSE; } return implementation->ReadFile(filename); }
void CreateOldStyleShortcut(HANDLE hContact, TCHAR *history_filename) { TCHAR shortcut[MAX_PATH] = _T(""); GetOldStyleAvatarName(shortcut, hContact); mir_sntprintf(shortcut, MAX_REGS(shortcut), _T("%s.%s.lnk"), shortcut, GetExtension(history_filename)); if (!CreateShortcut(history_filename, shortcut)) { ShowPopup(hContact, _T("Avatar History: Unable to create shortcut"), shortcut); } else { ShowDebugPopup(hContact, _T("AVH Debug: Shortcut created successfully"), shortcut); } }
void CDlgBOMExport::OnBrowse() { CString ext = GetExtension(); // Generate the filter string from the extension TCHAR szFilter[256]; _stprintf_s(szFilter, _T("Parts List (*%s)|*%s|All files (*.*)|*.*||"), ext, ext ); CFileDialog dlg( FALSE, _T("*")+ext, m_Filename, OFN_HIDEREADONLY, szFilter, AfxGetMainWnd() ); if (dlg.DoModal() == IDOK) { m_Filename = dlg.GetPathName(); UpdateData( FALSE ); } }
bool SpriteSheet2D::BeginLoad(Deserializer& source) { if (GetName().Empty()) SetName(source.GetName()); loadTextureName_.Clear(); spriteMapping_.Clear(); String extension = GetExtension(source.GetName()); if (extension == ".plist") return BeginLoadFromPListFile(source); if (extension == ".xml") return BeginLoadFromXMLFile(source); URHO3D_LOGERROR("Unsupported file type"); return false; }
SoundReader *SoundReader_FileReader::OpenFile( CString filename, CString &error ) { { RageFile TestOpen; if( !TestOpen.Open( filename ) ) { error = TestOpen.GetError(); return NULL; } } set<CString> FileTypes; FileTypes.insert("ogg"); FileTypes.insert("mp3"); FileTypes.insert("wav"); CString format = GetExtension(filename); format.MakeLower(); error = ""; bool bKeepTrying = true; /* If the extension matches a format, try that first. */ if( FileTypes.find(format) != FileTypes.end() ) { SoundReader_FileReader *NewSample = TryOpenFile( filename, error, format, bKeepTrying ); if( NewSample ) return NewSample; FileTypes.erase( format ); } for( set<CString>::iterator it = FileTypes.begin(); bKeepTrying && it != FileTypes.end(); ++it ) { SoundReader_FileReader *NewSample = TryOpenFile( filename, error, *it, bKeepTrying ); if( NewSample ) { LOG->Warn("File \"%s\" is really %s", filename.c_str(), it->c_str()); return NewSample; } } return NULL; }
// little helper function (to stay independent) void CResourceCompilerHelper::ReplaceExtension(const char* path, const char* new_ext, char* buffer, size_t bufferSizeInBytes) { const char* const ext = GetExtension(path); SettingsManagerHelpers::CFixedString<char, 512> p; if(ext) { p.set(path, ext - path); p.append(new_ext); } else { p.set(path); p.append("."); p.append(new_ext); } cry_strcpy(buffer, bufferSizeInBytes, p.c_str()); }
bool wxGISDataset::Rename(const wxString &sNewName, ITrackCancel* const pTrackCancel) { wxCriticalSectionLocker locker(m_CritSect); Close(); CPLString szDirPath = CPLGetPath(m_sPath); CPLString szName = CPLGetBasename(m_sPath); CPLString szNewName(ClearExt(sNewName).mb_str(wxConvUTF8)); char** papszFileList = GetFileList(); papszFileList = CSLAddString( papszFileList, m_sPath ); if(!papszFileList) { if(pTrackCancel) pTrackCancel->PutMessage(_("No files to rename"), wxNOT_FOUND, enumGISMessageErr); return false; } char **papszNewFileList = NULL; for(int i = 0; papszFileList[i] != NULL; ++i ) { CPLString szNewPath(CPLFormFilename(szDirPath, szNewName, GetExtension(papszFileList[i], szName))); papszNewFileList = CSLAddString(papszNewFileList, szNewPath); if(!RenameFile(papszFileList[i], papszNewFileList[i], pTrackCancel)) { // Try to put the ones we moved back. for( --i; i >= 0; i-- ) RenameFile( papszNewFileList[i], papszFileList[i]); CSLDestroy( papszFileList ); CSLDestroy( papszNewFileList ); return false; } } m_sPath = CPLString(CPLFormFilename(szDirPath, szNewName, CPLGetExtension(m_sPath))); CSLDestroy( papszFileList ); CSLDestroy( papszNewFileList ); return true; }
void Transition::Load( CString sBGAniDir ) { if( IsADirectory(sBGAniDir) && sBGAniDir.Right(1) != "/" ) sBGAniDir += "/"; this->RemoveAllChildren(); m_sprTransition.Load( sBGAniDir ); m_sprTransition->PlayCommand( "On" ); this->AddChild( m_sprTransition ); m_fLengthSeconds = m_sprTransition->GetTweenTimeLeft(); m_State = waiting; // load sound from file specified by ini, or use the first sound in the directory if( IsADirectory(sBGAniDir) ) { IniFile ini; ini.ReadFile( sBGAniDir+"/BGAnimation.ini" ); CString sSoundFileName; if( ini.GetValue("BGAnimation","Sound", sSoundFileName) ) { FixSlashesInPlace( sSoundFileName ); CString sPath = sBGAniDir+sSoundFileName; CollapsePath( sPath ); m_sound.Load( sPath ); } else { m_sound.Load( sBGAniDir ); } } else if( GetExtension(sBGAniDir).CompareNoCase("xml") == 0 ) { CString sSoundFile; XNode xml; xml.LoadFromFile( sBGAniDir ); if( xml.GetAttrValue( "Sound", sSoundFile ) ) m_sound.Load( Dirname(sBGAniDir) + sSoundFile ); } }
FileType GetFileType(const ea::string& fileName) { auto extension = GetExtension(fileName).to_lower(); if (archiveExtensions_.contains(extension)) return FTYPE_ARCHIVE; if (wordExtensions_.contains(extension)) return FTYPE_WORD; if (codeExtensions_.contains(extension)) return FTYPE_CODE; if (imagesExtensions_.contains(extension)) return FTYPE_IMAGE; if (textExtensions_.contains(extension)) return FTYPE_TEXT; if (audioExtensions_.contains(extension)) return FTYPE_AUDIO; if (extension == "pdf") return FTYPE_PDF; return FTYPE_FILE; }
bool wxGISDataset::Move(const CPLString &szDestPath, ITrackCancel* const pTrackCancel) { wxCriticalSectionLocker locker(m_CritSect); Close(); char** papszFileList = GetFileList(); papszFileList = CSLAddString( papszFileList, m_sPath ); if(!papszFileList) { if(pTrackCancel) pTrackCancel->PutMessage(_("No files to move"), wxNOT_FOUND, enumGISMessageErr); return false; } CPLString szFileName = CPLGetBasename(GetUniqPath(m_sPath, szDestPath, CPLGetBasename(m_sPath))); char** papszMovedFileList = NULL; for(int i = 0; papszFileList[i] != NULL; ++i ) { CPLString szNewDestFileName(CPLFormFilename(szDestPath, szFileName, GetExtension(papszFileList[i], szFileName))); papszMovedFileList = CSLAddString(papszMovedFileList, szNewDestFileName); if(!MoveFile(szNewDestFileName, papszFileList[i], pTrackCancel)) { // Try to put the ones we moved back. pTrackCancel->Reset(); for( --i; i >= 0; i-- ) MoveFile( papszFileList[i], papszMovedFileList[i]); CSLDestroy( papszFileList ); CSLDestroy( papszMovedFileList ); return false; } } m_sPath = CPLFormFilename(szDestPath, CPLGetFilename(m_sPath), NULL); CSLDestroy( papszFileList ); CSLDestroy( papszMovedFileList ); return true; }
void LocationDlg::OnLoadAnim( wxCommandEvent &event ) { wxString filter = _("Polyline Data Sources"); filter += _T("|"); AddType(filter, FSTRING_VTAP); AddType(filter, FSTRING_SHP); AddType(filter, FSTRING_DXF); AddType(filter, FSTRING_IGC); wxFileDialog loadFile(NULL, _("Load Animation Path"), _T(""), _T(""), filter, wxFD_OPEN); bool bResult = (loadFile.ShowModal() == wxID_OK); if (!bResult) return; vtAnimPath *anim; bool bSuccess; wxString str = loadFile.GetPath(); vtString filename = (const char *) str.mb_str(wxConvUTF8); if (GetExtension(filename) == ".vtap") { anim = CreateAnimPath(); bSuccess = anim->Read(filename); } else { vtFeatureLoader loader; vtFeatureSet *pSet = loader.LoadFrom(filename); if (!pSet) return; anim = CreateAnimPath(); bSuccess = anim->CreateFromLineString(m_pSaver->GetAtProjection(), pSet); delete pSet; } if (bSuccess) { AppendAnimPath(anim, filename); RefreshAnims(); } else delete anim; }
void Urho3D::Start() { #ifdef ENABLE_LUA String extension = GetExtension(scriptFileName_).ToLower(); if (extension != ".lua") { #endif // Instantiate and register the AngelScript subsystem context_->RegisterSubsystem(new Script(context_)); // Hold a shared pointer to the script file to make sure it is not unloaded during runtime scriptFile_ = context_->GetSubsystem<ResourceCache>()->GetResource<ScriptFile>(scriptFileName_); // If script loading is successful, proceed to main loop if (scriptFile_ && scriptFile_->Execute("void Start()")) { // Subscribe to script's reload event to allow live-reload of the application SubscribeToEvent(scriptFile_, E_RELOADSTARTED, HANDLER(Urho3D, HandleScriptReloadStarted)); SubscribeToEvent(scriptFile_, E_RELOADFINISHED, HANDLER(Urho3D, HandleScriptReloadFinished)); SubscribeToEvent(scriptFile_, E_RELOADFAILED, HANDLER(Urho3D, HandleScriptReloadFailed)); return; } #ifdef ENABLE_LUA } else { // Instantiate and register the Lua script subsystem context_->RegisterSubsystem(new LuaScript(context_)); LuaScript* luaScript = GetSubsystem<LuaScript>(); // If script loading is successful, proceed to main loop if (luaScript->ExecuteFile(scriptFileName_.CString())) { luaScript->ExecuteFunction("Start"); return; } } #endif // The script was not successfully loaded. Show the last error message and do not run the main loop ErrorExit(); }
bool BuildWindows::CheckIncludeResourceFile(const String& resourceDir, const String& fileName) { // #623 BEGIN TODO: Skip files that have a converted version in the cache AssetDatabase* db = GetSubsystem<AssetDatabase>(); String cachePath = db->GetCachePath(); if (resourceDir != cachePath) { String ext = GetExtension(fileName); if (ext == ".jpg" || ext == ".png" || ext == ".tga") { FileSystem* fileSystem = GetSubsystem<FileSystem>(); String compressedPath = cachePath + "DDS/" + fileName + ".dds"; if (fileSystem->FileExists(compressedPath)) return false; } } // #623 END TODO return BuildBase::CheckIncludeResourceFile(resourceDir, fileName); }
wxString ExportPlugin::GetMask() { if (!mMask.IsEmpty()) { return mMask; } wxString mask = GetDescription() + wxT("|"); // Build the mask, but cater to the Mac FileDialog and put the default // extension at the end of the mask. wxString ext = GetExtension(); wxArrayString exts = GetExtensions(); for (size_t i = 0; i < exts.GetCount(); i++) { if (ext != exts[i]) { mask += wxT("*.") + exts[i] + wxT(";"); } } return mask + wxT("*.") + ext; }
void ImportCmd::Run() { ToolSystem* tsystem = GetSubsystem<ToolSystem>(); Project* project = tsystem->GetProject(); String resourcePath = project->GetResourcePath(); String ext = GetExtension(assetFilename_); if (ext == ".json") { Poco::File file(assetFilename_.CString()); if (!file.exists()) { Error(ToString("JSON source scene does not exist: %s", assetFilename_.CString())); return; } LOGRAWF("Importing JSON: %s", assetFilename_.CString()); SharedPtr<JSONSceneImporter> jimporter; jimporter = new JSONSceneImporter(context_); jimporter->Import(assetFilename_); SharedPtr<JSONSceneProcess> sceneProcess; sceneProcess = new JSONSceneProcess(context_, jimporter); sceneProcess->Process(resourcePath); sceneProcess->Write(); } else { SharedPtr<OpenAssetImporter> importer(new OpenAssetImporter(context_)); if (importer->Load(assetFilename_)) { importer->ExportModel("/Users/josh/Desktop/ExportedModel.mdl"); } } Finished(); }
CString CExtensionListControl::CListItem::GetText(int subitem) const { switch (subitem) { case COL_EXTENSION: { return GetExtension(); } case COL_COLOR: { return _T("(color)"); } case COL_BYTES: { return FormatBytes(m_record.bytes); } case COL_FILES: { return FormatCount(m_record.files); } case COL_DESCRIPTION: { return GetDescription(); } case COL_BYTESPERCENT: { return GetBytesPercent(); } default: { ASSERT(0); return wds::strEmpty; } } }
void OggOpusFile::Open(CStdString& filename, fileOpenModeEnum mode, bool stereo, int sampleRate) { if(m_sampleRate == 0) { m_sampleRate = sampleRate; } if(!m_filename.Equals(filename)) { m_filename = filename + GetExtension(); } fout = NULL; m_mode = mode; if (mode == READ) { fout = ACE_OS::fopen((PCSTR)m_filename, "rb"); } else { FileRecursiveMkdir(m_filename, CONFIG.m_audioFilePermissions, CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup, CONFIG.m_audioOutputPathMcf); fout = ACE_OS::fopen((PCSTR)m_filename, "wb"); if(CONFIG.m_audioFilePermissions) { FileSetPermissions(m_filename, CONFIG.m_audioFilePermissions); } if(CONFIG.m_audioFileGroup.size() && CONFIG.m_audioFileOwner.size()) { FileSetOwnership(m_filename, CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup); } } if(!fout) { throw(CStdString("Could not open file: ") + m_filename); } Init(); WriteHeader(); //Close(); }
FileType ActorUtil::GetFileType( const RString &sPath ) { RString sExt = GetExtension( sPath ); sExt.MakeLower(); etft_cont_t::iterator conversion_entry= ExtensionToFileType.find(sExt); if(conversion_entry != ExtensionToFileType.end()) { return conversion_entry->second; } else if(sPath.size() > 0 && sPath[sPath.size()-1] == '/') { return FT_Directory; } /* Do this last, to avoid the IsADirectory in most cases. */ else if(IsADirectory(sPath)) { return FT_Directory; } return FileType_Invalid; }
bool C4ObjectInfo::Load(C4Group &hMother, const char *szEntryname) { // New version if (SEqualNoCase(GetExtension(szEntryname),"oci")) { C4Group hChild; if (hChild.OpenAsChild(&hMother,szEntryname)) { if (!C4ObjectInfo::Load(hChild)) { hChild.Close(); return false; } // resolve definition, if possible // only works in game, but is not needed in frontend or startup editing anyway pDef = C4Id2Def(id); hChild.Close(); return true; } } return false; }