unichar_t *_GioMacMime(const char *path) { /* If we're on a mac, we can try to see if we've got a real resource fork */ FSRef ref; FSCatalogInfo info; if ( FSPathMakeRef( (uint8 *) path,&ref,NULL)!=noErr ) return( NULL ); if ( FSGetCatalogInfo(&ref,kFSCatInfoFinderInfo,&info,NULL,NULL,NULL)!=noErr ) return( NULL ); if ( ((FInfo *) (info.finderInfo))->fdType==CHR('F','F','I','L') ) return( fontmacsuit ); if ( ((FInfo *) (info.finderInfo))->fdType==CHR('G','I','F','f') ) return( imagegif ); if ( ((FInfo *) (info.finderInfo))->fdType==CHR('P','N','G',' ') ) return( imagepng ); /* if ( ((FInfo *) (info.finderInfo))->fdType==CHR('B','M','P',' ') ) return( imagebmp ); */ if ( ((FInfo *) (info.finderInfo))->fdType==CHR('J','P','E','G') ) return( imagejpeg ); /* if ( ((FInfo *) (info.finderInfo))->fdType==CHR('T','I','F','F') ) return( imagetiff ); */ if ( ((FInfo *) (info.finderInfo))->fdType==CHR('T','E','X','T') ) return( textplain ); return( NULL ); }
OSErr makeFSSpec(char *pathString, int pathStringLength,FSSpec *spec) { CFURLRef sillyThing; CFStringRef tmpStrRef; CFMutableStringRef filePath; FSRef theFSRef; OSErr err; tmpStrRef = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *) pathString, pathStringLength, gCurrentVMEncoding, true); if (tmpStrRef == nil) return -1000; filePath = CFStringCreateMutableCopy(NULL, 0, tmpStrRef); if (gCurrentVMEncoding == kCFStringEncodingUTF8) CFStringNormalize(filePath, kCFStringNormalizationFormD); sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLHFSPathStyle,false); if (sillyThing == NULL) return -2000; if (CFURLGetFSRef(sillyThing,&theFSRef) == false) { // name contains multiple aliases or does not exist, so fallback to lookupPath CFRelease(filePath); CFRelease(sillyThing); return lookupPath(pathString,pathStringLength,spec,true,true); } CFRelease(filePath); err = FSGetCatalogInfo (&theFSRef,kFSCatInfoNone,nil,nil,spec,nil); CFRelease(sillyThing); return err; }
Boolean nav_file_filter(AEDesc *theItem,void *info,void *callBackUD,NavFilterModes filterMode) { char *c,filename[256]; NavFileOrFolderInfo *filefolder; AEDesc desc; HFSUniStr255 uniname; CFStringRef cfstr; FSRef fref; if ((theItem->descriptorType!=typeFSS) && (theItem->descriptorType!=typeFSRef)) return(FALSE); filefolder=(NavFileOrFolderInfo*)info; if (filefolder->isFolder) return(TRUE); AECoerceDesc(theItem,typeFSRef,&desc); AEGetDescData(&desc,(void*)&fref,sizeof(FSRef)); AEDisposeDesc(&desc); FSGetCatalogInfo(&fref,kFSCatInfoNone,NULL,&uniname,NULL,NULL); cfstr=CFStringCreateWithCharacters(kCFAllocatorDefault,uniname.unicode,uniname.length); CFStringGetCString(cfstr,filename,256,kCFStringEncodingMacRoman); CFRelease(cfstr); c=strchr(filename,'.'); if (c==NULL) return(FALSE); return(strcasecmp((c+1),nav_filetype)==0); }
OpBitmap* GetAttachmentIconOpBitmap(const uni_char* filename, BOOL big_attachment_icon, int iSize) { int cx, cy; OpBitmap* result = 0; SInt16 label; IconRef iconRef; FSRef fsref; if(OpFileUtils::ConvertUniPathToFSRef(filename, fsref)) { FSCatalogInfo info; if(noErr == FSGetCatalogInfo(&fsref, kIconServicesCatalogInfoMask, &info, NULL, NULL, NULL)) { if(noErr == GetIconRefFromFileInfo(&fsref, 0, NULL, kIconServicesCatalogInfoMask, &info, kIconServicesNormalUsageFlag, &iconRef, &label)) { if (!iSize) cx = cy = big_attachment_icon ? 32 : 16; else cx = cy = iSize; result = CreateOpBitmapFromIcon(iconRef, cx, cy); ReleaseIconRef(iconRef); } } } return result; }
int SetFileComment(std::string spath, std::string scomment) { const char *path = spath.c_str(); const char *comment = scomment.c_str(); OSErr err = noErr; FSRef fileRef; FSSpec fileSpec; // see if the file in question exists and we can write it if (access(path, R_OK | W_OK | F_OK) == - 1) { return 1; } // get file reference from path err = FSPathMakeRef( (const UInt8 *) path, &fileRef, NULL); if (err != noErr) { return 1; } // retrieve filespec from file ref err = FSGetCatalogInfo(&fileRef, NULL, NULL, NULL, &fileSpec, NULL); if (err != noErr) { return 1; } // being by setting MacOS X Finder Comment Str255 pCommentStr; CopyCStringToPascal(comment, pCommentStr); err = MoreFESetComment(&fileSpec, pCommentStr, NULL); if (err != noErr) { return 1; } return 0; }
FT_GetFile_From_Mac_ATS_Name( const char* fontName, FSSpec* pathSpec, FT_Long* face_index ) { #if ( __LP64__ ) || ( defined( MAC_OS_X_VERSION_10_5 ) && \ ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 ) ) FT_UNUSED( fontName ); FT_UNUSED( pathSpec ); FT_UNUSED( face_index ); return FT_Err_Unimplemented_Feature; #else FSRef ref; FT_Error err; err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index ); if ( FT_Err_Ok != err ) return err; if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL, pathSpec, NULL ) ) return FT_Err_Unknown_File_Format; return FT_Err_Ok; #endif }
boolean getfsvolume ( const ptrfilespec fs, long *vnum ) { // // 2006-07-12 creedon: for Mac, FSRef-ized // // 5.1.5b11 dmb: get the volume that is actually specified in the fspec. // // don't expand partial paths using the default directory. // #ifdef MACVERSION FSCatalogInfo catalogInfo; OSErr err = FSGetCatalogInfo ( &fs->ref, kFSCatInfoVolume, &catalogInfo, NULL, NULL, NULL ); if ( catalogInfo.volume == 0 ) return ( false ); *vnum = catalogInfo.volume; return ( err == noErr ); #endif #ifdef WIN95VERSION *vnum = 0; return ( true ); #endif } // getfsvolume
bool HLFileSystemObject::IsVolume() const { FSCatalogInfo theCatalogInfo; OSStatus theError = FSGetCatalogInfo(&mFSRef, kFSCatInfoNodeFlags | kFSCatInfoNodeID, &theCatalogInfo, NULL, NULL, NULL); ThrowIfError(theError, CAException(theError), "HLFileSystemObject::IsVolume: couldn't get the catalog info"); return ((theCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask) != 0) && (theCatalogInfo.nodeID == fsRtDirID); }
bool HLFileSystemObject::IsFile() const { FSCatalogInfo theCatalogInfo; OSStatus theError = FSGetCatalogInfo(&mFSRef, kFSCatInfoNodeFlags, &theCatalogInfo, NULL, NULL, NULL); ThrowIfError(theError, CAException(theError), "HLFileSystemObject::IsFile: couldn't get the catalog info"); return (theCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask) == 0; }
static OSStatus MyIsVisibleFile(const FSRef *ref, Boolean *visible) // Determine whether a ref points to a visible file. // // I really want to call LSCopyItemInfoForRef and test the resulting // flags for kLSItemInfoIsInvisible and kLSItemInfoIsPlainFile, but // if I do that I have to take a dependency on Launch Services, which // is part of ApplicationServices.framework [3101095]. That's not // acceptable, because this code is commonly used in a setuid root helper // tool and such a tool should depend on the minimal set of services, // so I roll my own visibility test code. { OSStatus err; FSCatalogInfo info; HFSUniStr255 name; assert(ref != NULL); assert(visible != NULL); err = FSGetCatalogInfo(ref, kFSCatInfoNodeFlags | kFSCatInfoFinderInfo, &info, &name, NULL, NULL); if (err == noErr) { *visible = ((info.nodeFlags & kFSNodeIsDirectoryMask) == 0) // file && ((((FInfo *) &info.finderInfo[0])->fdFlags & kIsInvisible) == 0) // visible && (name.unicode[0] != '.'); // doesn't begin with . } return err; }
static PyObject *AE_GetAppTerminology(PyObject* self, PyObject* args) { #if defined(__LP64__) PyErr_SetString(PyExc_NotImplementedError, "aem.ae.getappterminology isn't available in 64-bit processes."); return NULL; #else static ComponentInstance defaultComponent; FSRef fsRef; FSSpec fss; AEDesc theDesc; Boolean didLaunch; OSAError err; if (!PyArg_ParseTuple(args, "O&", AE_GetFSRef, &fsRef)) return NULL; err = FSGetCatalogInfo(&fsRef, kFSCatInfoNone, NULL, NULL, &fss, NULL); if (err != noErr) return AE_MacOSError(err); if (!defaultComponent) { defaultComponent = OpenDefaultComponent(kOSAComponentType, 'ascr'); err = GetComponentInstanceError(defaultComponent); if (err) return AE_MacOSError(err); } err = OSAGetAppTerminology(defaultComponent, kOSAModeNull, &fss, 0, &didLaunch, &theDesc); if (err) return AE_MacOSError(err); return BuildTerminologyList(&theDesc, typeAETE); #endif }
void ofxQtAudioRecorder::createMovie(string url, int sampleRate, int numChannels){ OSErr err = noErr; FSRef fsref; Boolean isdir; // full data path url = ofToDataPath(url, true); // kill a file and make a new one if needed: FILE * pFile; pFile = fopen (url.c_str(),"w"); fclose (pFile); // create path reference err = FSPathMakeRef((const UInt8*)url.c_str(), &fsref, &isdir); if (err) { printf("FSPathMakeRef failed %d\n", err); printf("ERROR creating movie \n"); return; } // create file spec err = FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, NULL, &myFileSpec, NULL); if (err) { printf("FSGetCatalogInfo failed %d\n", err); printf("ERROR creating movie \n"); return; } // create that movie file err = CreateMovieFile(&myFileSpec, 'TVOD', smCurrentScript, createMovieFileDeleteCurFile | createMovieFileDontCreateResFile, &movieResRefNum, &movie); if(err) { printf("error: failed to create movie file\n"); return; } prepareAudioRecording(sampleRate, numChannels); }
short file_attr(const char *path) { Str255 fname; FSSpec fss; FSRef fsr; FSCatalogInfo fsci; short ret; mkstr255(fname, path); if ((FSMakeFSSpec(0, 0, fname, &fss) != noErr) || (FSpMakeFSRef(&fss, &fsr) != noErr) || (FSGetCatalogInfo(&fsr, kFSCatInfoNodeFlags, &fsci, NULL, NULL, NULL) != noErr)) { return(-1); } if (fsci.nodeFlags & kFSNodeIsDirectoryMask) { ret = FILEATTR_DIRECTORY; } else { ret = FILEATTR_ARCHIVE; } if (fsci.nodeFlags & kFSNodeLockedMask) { ret |= FILEATTR_READONLY; } return(ret); }
void QStorageInfoPrivate::retrieveLabel() { #if !defined(Q_OS_IOS) // deprecated since 10.8 FSRef ref; FSPathMakeRef(reinterpret_cast<const UInt8*>(QFile::encodeName(rootPath).constData()), &ref, Q_NULLPTR); // deprecated since 10.8 FSCatalogInfo catalogInfo; OSErr error; error = FSGetCatalogInfo(&ref, kFSCatInfoVolume, &catalogInfo, Q_NULLPTR, Q_NULLPTR, Q_NULLPTR); if (error != noErr) { return; } // deprecated (use CFURLCopyResourcePropertiesForKeys for 10.7 and higher) HFSUniStr255 volumeName; error = FSGetVolumeInfo(catalogInfo.volume, 0, Q_NULLPTR, kFSVolInfoFSInfo, Q_NULLPTR, &volumeName, Q_NULLPTR); if (error == noErr) { name = QCFString(FSCreateStringFromHFSUniStr(Q_NULLPTR, &volumeName)); } #endif }
void fixmacfile(char *filename) { FInfo fndrinfo; #ifdef OSX_CARBON FSSpec fileSpec; FSRef fileRef; FSPathMakeRef((unsigned char *)filename, &fileRef, NULL); FSGetCatalogInfo(&fileRef, kFSCatInfoNone, NULL, NULL, &fileSpec, NULL); FSpGetFInfo(&fileSpec, &fndrinfo); fndrinfo.fdType='TEXT'; fndrinfo.fdCreator='MSWD'; FSpSetFInfo(&fileSpec, &fndrinfo); #else char filename1[FNMLNGTH]; char filename2[FNMLNGTH]; strcpy(filename1,filename); strcpy(filename2,filename); getfinfo(filename1,0,&fndrinfo); fndrinfo.fdType='TEXT'; fndrinfo.fdCreator='MSWD'; setfinfo(filename2,0,&fndrinfo); #endif }
void Initialize(const std::string& location) { path_ = CFStringCreateWithCString(kCFAllocatorDefault, location.c_str(), kCFStringEncodingUTF8); if(!path_) { std::cout << "KotoeriImpl: CFStringCreateCopy() failed" << std::endl; return; } FSSpec spec; FSRef fileRef; CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path_, kCFURLPOSIXPathStyle, false); OSErr err = !noErr; if(CFURLGetFSRef(url, &fileRef)) { err = FSGetCatalogInfo(&fileRef, kFSCatInfoNone, NULL, NULL, &spec, NULL); } if(url) CFRelease(url); if(err != noErr) { return; } if(DCMGetDictionaryIDFromFile(&spec, &id_) != noErr) { std::cout << "DCMGetDictionaryIDFromFile() failed" << std::endl; if(DCMRegisterDictionaryFile(&spec, &id_) != noErr) { std::cout << "DCMRegisterDictionaryFile() failed" << std::endl; return; } isRegistered_ = true; } }
bool HLDirectoryFactory::ObjectIsA(const FSRef& inFSRef) const { FSCatalogInfo theCatalogInfo; OSStatus theError = FSGetCatalogInfo(&inFSRef, kFSCatInfoNodeFlags, &theCatalogInfo, NULL, NULL, NULL); ThrowIfError(theError, CAException(theError), "HLDirectoryFactory::ObjectIsA: couldn't get the catalog info"); return (theCatalogInfo.nodeFlags & kFSNodeIsDirectoryMask) != 0; }
static void PrintOSXComment (char *path) { OSErr err = noErr; FSRef fileRef; FSSpec fileSpec; Str255 comment = "\p"; char cStrCmt[255] = "\0"; AEIdleUPP inIdleProc = NewAEIdleUPP(&MyAEIdleCallback); ///////////// Make sure we can do as we please :) ///////////// //see if the file in question exists and we can write it if (access(path, R_OK|F_OK) == -1) { perror(path); return; } //get file reference from path err = FSPathMakeRef(path, &fileRef, NULL); if (err != noErr) { fprintf(stderr, "FSPathMakeRef: Error %d for file %s\n", err, path); return; } //retrieve filespec from file ref err = FSGetCatalogInfo (&fileRef, NULL, NULL, NULL, &fileSpec, NULL); if (err != noErr) { fprintf(stderr, "FSGetCatalogInfo(): Error %d getting file spec for %s\n", err, path); return; } ///////////// oK, now we can go about getting the comment ///////////// // call the apple event routine. I'm not going to pretend I understand what's going on // in all those horribly kludgy functions, but at least it works. err = MoreFEGetComment(&fileRef, &fileSpec, comment, inIdleProc); if (err) { fprintf(stderr, "Error %d getting comment for '%s'\n", err, path); if (err == -600) fprintf(stderr, "Finder is not running\n", err);//requires Finder to be running return; } //convert pascal string to c string strncpy((char *)&cStrCmt, (unsigned char *)&comment+1, comment[0]); //if there is no comment, we don't print out anything if (!strlen((char *)&cStrCmt)) return; //print out the comment if (!printFileName) printf("%s\n", (char *)&cStrCmt); else printf("Comment for '%s':\n%s\n", path, (char *)&cStrCmt); }
void wxMacFilename2FSSpec( const wxString& path , FSSpec *spec ) { OSStatus err = noErr; FSRef fsRef; wxMacPathToFSRef( path , &fsRef ); err = FSGetCatalogInfo(&fsRef, kFSCatInfoNone, NULL, NULL, spec, NULL); verify_noerr( err ); }
// Don't use this function, it won't work in 10.5 (Leopard) and up OSErr qt_mac_create_fsspec(const QString &file, FSSpec *spec) { FSRef fsref; OSErr ret = qt_mac_create_fsref(file, &fsref); if (ret == noErr) ret = FSGetCatalogInfo(&fsref, kFSCatInfoNone, 0, 0, spec, 0); return ret; }
bool createMovieFromPath(char * path, Movie &movie){ Boolean isdir = false; OSErr result = 0; FSSpec theFSSpec; short actualResId = DoTheRightThing; #ifdef TARGET_WIN32 result = NativePathNameToFSSpec (path, &theFSSpec, 0); if (result != noErr) { ofLog(OF_LOG_ERROR,"NativePathNameToFSSpec failed %d", result); ofLog(OF_LOG_ERROR,"Error loading movie"); return false; } #endif #ifdef TARGET_OSX FSRef fsref; result = FSPathMakeRef((const UInt8*)path, &fsref, &isdir); if (result) { ofLog(OF_LOG_ERROR,"FSPathMakeRef failed %d", result); ofLog(OF_LOG_ERROR,"Error loading movie"); return false; } result = FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, NULL, &theFSSpec, NULL); if (result) { ofLog(OF_LOG_ERROR,"FSGetCatalogInfo failed %d", result); ofLog(OF_LOG_ERROR,"Error loading movie"); return false; } #endif short movieResFile; result = OpenMovieFile (&theFSSpec, &movieResFile, fsRdPerm); if (result == noErr) { short movieResID = 0; result = NewMovieFromFile(&movie, movieResFile, &movieResID, (unsigned char *) 0, newMovieActive, (Boolean *) 0); if (result == noErr){ CloseMovieFile (movieResFile); } else { ofLog(OF_LOG_ERROR,"NewMovieFromFile failed %d", result); return false; } } else { ofLog(OF_LOG_ERROR,"OpenMovieFile failed %d", result); return false; } return true; }
short file_attr(const char *path) { #ifdef TARGET_API_MAC_CARBON Str255 fname; FSSpec fss; FSRef fsr; FSCatalogInfo fsci; short ret; mkstr255(fname, path); if ((FSMakeFSSpec(0, 0, fname, &fss) != noErr) || (FSpMakeFSRef(&fss, &fsr) != noErr) || (FSGetCatalogInfo(&fsr, kFSCatInfoNodeFlags, &fsci, NULL, NULL, NULL) != noErr)) { return(-1); } if (fsci.nodeFlags & kFSNodeIsDirectoryMask) { ret = FILEATTR_DIRECTORY; } else { ret = FILEATTR_ARCHIVE; } if (fsci.nodeFlags & kFSNodeLockedMask) { ret |= FILEATTR_READONLY; } return(ret); #else Str255 fname; FSSpec fss; CInfoPBRec pb; short ret; mkstr255(fname, path); FSMakeFSSpec(0, 0, fname, &fss); pb.dirInfo.ioNamePtr = fss.name; pb.dirInfo.ioVRefNum = fss.vRefNum; pb.dirInfo.ioDrDirID = fss.parID; if (fss.name[0] == 0) { pb.dirInfo.ioFDirIndex = -1; } else { pb.dirInfo.ioFDirIndex = 0; } if (PBGetCatInfo(&pb, false) != noErr) { return(-1); } if (pb.hFileInfo.ioFlAttrib & ioDirMask) { ret = FILEATTR_DIRECTORY; } else { ret = FILEATTR_ARCHIVE; } if (pb.hFileInfo.ioFlAttrib & 0x01) { ret |= FILEATTR_READONLY; } return(ret); #endif }
OSErr getFInfoViaFSRef(FSRef *theFSRef, FInfo *finderInfo) { OSErr err; FSCatalogInfo catInfo; err = FSGetCatalogInfo (theFSRef,kFSCatInfoFinderInfo,&catInfo,nil,nil,nil); memcpy(finderInfo,&catInfo.finderInfo,sizeof(FInfo)); return err; }
FBL_Begin_Namespace /**********************************************************************************************/ #if FBL_MAC /**********************************************************************************************/ // NOTE: fullPath to item that EXISTS on disk. Otherwise file not found error. // #if FBL_SUPPORT_FSSPEC // OSErr Path2Spec_FSRef( const char *inPath, FSSpec *spec) { // parse path on parent folder and file name. const char* pFileName = ExtractNameFromFullPath(inPath); const char* pDelim = pFileName - 1; // String folder_path( inPath, vuint32(pDelim - inPath) ); vuint32 len; if( pDelim >= inPath ) len = vuint32(pDelim - inPath); else len = strlen( inPath ); MemPtr<char> folder_path( inPath, len + 1 ); folder_path[len] = 0; char* pFolderPath = folder_path.begin(); // convert the POSIX path to an FSRef of parent folder FSRef ref; OSStatus result = FSPathMakeRef( (vuint8*) pFolderPath, &ref, NULL); if( result != 0 ) return (OSErr) result; // and then convert the FSRef to an FSSpec FSSpec parent; result = FSGetCatalogInfo(&ref, kFSCatInfoNone, NULL, NULL, &parent, NULL); if( result != 0 ) return (OSErr) result; // now we have parent folder FSSpec, get its ID. vint32 theDirID; bool isDirectory; GetDirectoryID( parent.vRefNum, parent.parID, parent.name, &theDirID, &isDirectory ); // and now we make File spec: Str255 pasFileName; FBL::c2pstrcpy( pFileName, pasFileName ); result = FSMakeFSSpec( parent.vRefNum, theDirID, pasFileName, spec ); return (OSErr) result; }
int main(int argc, char **argv) { if (argc < 2) { printf("Usage: %s <save file>\n", argv[0]); printf("Applies the creator and type codes so the save can be used\n"); printf("by the original interpreter.\n"); return 0; } uint32 creator, type; // First, let's open our file to make sure it's a pegasus save // Also, we're going to extract what type we need to set (for the correct disc) try { Common::File file(argv[1], "rb"); // Let's make sure the user already gunzip'd the file uint16 gzipTest = file.readUint16BE(); if (gzipTest == 0x1F8B) { printf("Please gunzip the save file first\n"); return 1; } creator = (gzipTest << 16) | file.readUint16BE(); // Too lazy to seek back :P type = file.readUint32BE(); if (creator != kPegasusCreator) { printf("Failed to find pegasus creator in save file\n"); return 1; } if (type != kPegasusDisc1 && type != kPegasusDisc2 && type != kPegasusDisc3 && type != kPegasusDisc4) { printf("Invalid pegasus save type in save file\n"); return 1; } } catch (Common::FileException e) { printf("File error: '%s'\n", e.what()); return 1; } FSCatalogInfo catInfo; FSRef ref; if (!FSPathMakeRef((const UInt8 *)argv[1], &ref, false)) { FSGetCatalogInfo(&ref, kFSCatInfoFinderInfo, &catInfo, 0, 0, 0); FileInfo *info = (FileInfo *)catInfo.finderInfo; info->fileCreator = creator; info->fileType = type; FSSetCatalogInfo(&ref, kFSCatInfoFinderInfo, &catInfo); } else { printf("Failed to use File Manager to open the file\n"); return 1; } printf("Success!\n"); return 0; }
static OSErr getFInfo(char *filename,FSCatalogInfo *catInfo,CFStringEncoding encoding) { FSRef theFSRef; OSErr err; err = getFSRef(filename,&theFSRef,encoding); if (err != 0) return err; err = FSGetCatalogInfo (&theFSRef,kFSCatInfoFinderInfo,catInfo,nil,nil,nil); return noErr; }
CFStringRef HLFileSystemObject::CopyName() const { // get the whole unicode name from the catalog info HFSUniStr255 theUniStr255; OSStatus theError = FSGetCatalogInfo(&mFSRef, kFSCatInfoNone, NULL, &theUniStr255, NULL, NULL); ThrowIfError(theError, CAException(theError), "HLFileSystemObject::CopyName: couldn't get the catalog information"); // make a CFString with it return CFStringCreateWithCharacters(NULL, theUniStr255.unicode, theUniStr255.length); }
static OSErr FSGetFInfo(const FSRef* ref, FInfo *fInfo) { FSCatalogInfo cinfo; OSErr err = FSGetCatalogInfo(ref, kFSCatInfoFinderInfo, &cinfo, NULL, NULL, NULL); if (err != noErr) return err; *fInfo = *(FInfo*)cinfo.finderInfo; return err; }
OSStatus PathToFSSpec(const char *filename, FSSpec &outSpec) { FSRef fsRef; OSStatus result; require_noerr (result = FSPathMakeRef ((const UInt8*)filename, &fsRef, 0), home); require_noerr (result = FSGetCatalogInfo(&fsRef, kFSCatInfoNone, NULL, NULL, &outSpec, NULL), home); home: return result; }
static bool isPackage(const QFileSystemMetaData &data, const QFileSystemEntry &entry) { if (!data.isDirectory()) return false; QFileInfo info(entry.filePath()); QString suffix = info.suffix(); if (suffix.length() > 0) { // First step: is the extension known ? CFStringRef extensionRef = QCFString::toCFStringRef(suffix); CFStringRef uniformTypeIdentifier = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, extensionRef, NULL); if (UTTypeConformsTo(uniformTypeIdentifier, kUTTypeBundle)) return true; // Second step: check if an application knows the package type CFStringRef path = QCFString::toCFStringRef(entry.filePath()); QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, path, kCFURLPOSIXPathStyle, true); UInt32 type, creator; // Well created packages have the PkgInfo file if (CFBundleGetPackageInfoInDirectory(url, &type, &creator)) return true; // Find if an application other than Finder claims to know how to handle the package QCFType<CFURLRef> application; LSGetApplicationForURL(url, kLSRolesEditor|kLSRolesViewer|kLSRolesViewer, NULL, &application); if (application) { QCFType<CFBundleRef> bundle = CFBundleCreate(kCFAllocatorDefault, application); CFStringRef identifier = CFBundleGetIdentifier(bundle); QString applicationId = QCFString::toQString(identifier); if (applicationId != QLatin1String("com.apple.finder")) return true; } } // Third step: check if the directory has the package bit set FSRef packageRef; FSPathMakeRef((UInt8 *)entry.nativeFilePath().constData(), &packageRef, NULL); FSCatalogInfo catalogInfo; FSGetCatalogInfo(&packageRef, kFSCatInfoFinderInfo, &catalogInfo, NULL, NULL, NULL); FolderInfo *folderInfo = reinterpret_cast<FolderInfo *>(catalogInfo.finderInfo); return folderInfo->finderFlags & kHasBundle; }