filespecutils.cpp

linux下的一款播放器

								
								pNewDirSpec = new CHXDirSpecifier(targetFSSpec);
								check_nonnull(pNewDirSpec);
								
								if (pNewDirSpec)
								{
									specArray.Add(pNewDirSpec);
								}
								
							}
						}
					}
				} // while (!bDoneWithThisDirectory)
			}
		}
	} // while(!specArray.IsEmpty())
	
	fSize = totalSize;
	return HXR_OK;
}

// ------------------------------------------------------------------------------------
//
// GetCurrentApplication
// GetCurrentApplicationDir
//
// ------------------------------------------------------------------------------------

CHXFileSpecifier CHXFileSpecUtils::GetCurrentApplication()
{
	OSErr					err;
	FSSpec 					appFSSpec;
	ProcessSerialNumber 	appPSN = { 0, kCurrentProcess };
	ProcessInfoRec 			appPIR;
	CHXFileSpecifier 		appSpec;
	
	appPIR.processInfoLength = sizeof(ProcessInfoRec);
	appPIR.processAppSpec = &appFSSpec;
	appPIR.processName = NULL;
	
	err = GetProcessInformation(&appPSN, &appPIR);
	check_noerr(err);
	
	if (err == noErr)
	{
		appSpec = appFSSpec;
	}
	return appSpec;
}

CHXDirSpecifier CHXFileSpecUtils::GetCurrentApplicationDir()
{
	CHXFileSpecifier 	appSpec;
	CHXDirSpecifier 	dirSpec;
	
	appSpec = GetCurrentApplication();
	if (appSpec.IsSet())
	{
		dirSpec = appSpec.GetParentDirectory();
	}
	return dirSpec;
}

// ------------------------------------------------------------------------------------
//
// FileExists
// DirectoryExists
//
// ------------------------------------------------------------------------------------

#ifndef USE_FSREFS

static BOOL FSSpecExists(FSSpecPtr itemSpec, BOOL *isDirectory);	// Forward declaration

BOOL CHXFileSpecUtils::FileExists(const CHXFileSpecifier& fileSpec)
{
	FSSpec 	fileFSSpec;
	BOOL	isDirectory;
	
	require_return(fileSpec.IsSet(), FALSE);
	
	fileFSSpec = fileSpec;
	
	return FSSpecExists(&fileFSSpec, &isDirectory) && !isDirectory;
}

BOOL CHXFileSpecUtils::DirectoryExists(const CHXDirSpecifier& dirSpec)
{
	FSSpec 	dirFSSpec;
	BOOL	isDirectory;
	
	require_return(dirSpec.IsSet(), FALSE);
	
	dirFSSpec = dirSpec;
	
	return FSSpecExists(&dirFSSpec, &isDirectory) && isDirectory;
}

static BOOL FSSpecExists(FSSpecPtr itemSpec, BOOL *isDirectory)
{
	OSErr		err;
	CInfoPBRec	cInfo;
	FSSpec		tempSpec;
	BOOL		bExists;
	
	bExists = FALSE;
	
	// copy the provided file spec so PBGetCatInfo doesn't change the name
	tempSpec = *itemSpec;
	
	cInfo.dirInfo.ioVRefNum = tempSpec.vRefNum;
	cInfo.dirInfo.ioDrDirID = tempSpec.parID;
	cInfo.dirInfo.ioNamePtr = tempSpec.name;
	cInfo.dirInfo.ioFDirIndex = 0;	// use name, vRefNum, and dirID
	err = PBGetCatInfoSync(&cInfo);
	
	if (err == noErr)
	{
		bExists = TRUE;
		if (isDirectory)
		{
			if ((cInfo.hFileInfo.ioFlAttrib & ioDirMask) != 0)
			{
				*isDirectory = TRUE;
			}
			else
			{
				*isDirectory = FALSE;
			}
		}
	}
	
	return bExists;
}

#else // defined USE_FSREFS

static BOOL FSRefExists(const FSRef * itemSpec, BOOL *isDirectory);	// Forward declaration

BOOL CHXFileSpecUtils::FileExists(const CHXFileSpecifier& fileSpec)
{
	FSRef 	fileRef;
	BOOL	isDirectory;
	
	require_return(fileSpec.IsSet(), FALSE);
	
	fileRef = fileSpec;
	
 	return FSRefExists(&fileRef, &isDirectory) && !isDirectory;
}

BOOL CHXFileSpecUtils::DirectoryExists(const CHXDirSpecifier& dirSpec)
{
	FSRef 	dirRef;
	BOOL	isDirectory;
	
	require_return(dirSpec.IsSet(), FALSE);
	
	dirRef = dirSpec;
	
	return FSRefExists(&dirRef, &isDirectory) && isDirectory;
}

static BOOL FSRefExists(const FSRef *itemRef, BOOL *isDirectory)
{
	OSErr		err;
	BOOL		bExists;
	FSCatalogInfo 	catInfo;
	
	const FSCatalogInfoBitmap whichInfo = kFSCatInfoNodeID | kFSCatInfoNodeFlags;

	HFSUniStr255 * kDontWantName = NULL;
	FSSpec * kDontWantFSSpec = NULL;
	FSRef * kDontWantParentRef = NULL;
	
	bExists = FALSE;
	
	err = ::FSGetCatalogInfo(itemRef, whichInfo, &catInfo,
		kDontWantName, kDontWantFSSpec, kDontWantParentRef);
		
	if (err == noErr)
	{
		bExists = TRUE;
		if (isDirectory)
		{
			if ((catInfo.nodeFlags & kFSNodeIsDirectoryMask) != 0)
			{
				*isDirectory = TRUE;
			}
			else
			{
				*isDirectory = FALSE;
			}
		}
	}
	
	return bExists;
}

#endif // defined USE_FSREFS

// ------------------------------------------------------------------------------------
//
// CreateDirectory
//
// ------------------------------------------------------------------------------------

HX_RESULT CHXFileSpecUtils::CreateDir(const CHXDirSpecifier& dirSpec)
{
	FSSpec 	dirFSSpec;
	long	dirID;
	OSErr	err;
	
	require_return(dirSpec.IsSet(), HXR_INVALID_PARAMETER);
	
	dirFSSpec = dirSpec;
	
	err = FSpDirCreate(&dirFSSpec, smSystemScript, &dirID);
	
	return err;
}

// ------------------------------------------------------------------------------------
//
// RemoveDir - deletes an empty directory
//
// ------------------------------------------------------------------------------------

HX_RESULT CHXFileSpecUtils::RemoveDir(const CHXDirSpecifier& dirSpec)
{
	FSSpec 	dirFSSpec;
	OSErr	err;
	
	require_return(dirSpec.IsSet(), HXR_INVALID_PARAMETER);
	
	dirFSSpec = dirSpec;
	
	err = FSpDelete(&dirFSSpec);
	
	return err;
}

// ------------------------------------------------------------------------------------
//
// RemoveFile
//
// ------------------------------------------------------------------------------------

HX_RESULT CHXFileSpecUtils::RemoveFile(const CHXFileSpecifier& fileSpec)
{
	FSSpec 	fileFSSpec;
	OSErr	err;
	
	require_return(fileSpec.IsSet(), HXR_INVALID_PARAMETER);
	
	fileFSSpec = fileSpec;
	
	err = FSpDelete(&fileFSSpec);
	
	return err;
}

// ------------------------------------------------------------------------------------
//
// GetFileType
//
// ------------------------------------------------------------------------------------

FOURCC CHXFileSpecUtils::GetFileType(const CHXFileSpecifier& fileSpec)
{
	FOURCC fileType;
	OSErr err;
	
	require_return(fileSpec.IsSet(), HXR_INVALID_PARAMETER);
	
	fileType = 0;
	
	if (fileSpec.IsSet())
	{
#ifdef USE_FSREFS
		FSRef		fileRef;
		FinderInfo	fndrInfo;
		Boolean		isDir;
		
		ExtendedFinderInfo * kDontWantExtendedInfo = NULL;
		
		fileRef = fileSpec;
		
		err = FSGetFinderInfo(&fileRef, &fndrInfo, kDontWantExtendedInfo, &isDir);
		
		if ((err == noErr) && !isDir)
		{
			fileType = fndrInfo.file.fileType;
		}

#else
		FSSpec	fileFSSpec;
		FInfo	fndrInfo;
		
		fileFSSpec = fileSpec;
		
		err = FSpGetFInfo(&fileFSSpec, &fndrInfo);
		check_noerr(err);
		
		if (err == noErr)
		{
			fileType = fndrInfo.fdType;
		}
#endif
	}
	
	return fileType;
}

// ------------------------------------------------------------------------------------
//
// MakeNameLegal
//
// returns TRUE if the name was changed
//
// ------------------------------------------------------------------------------------

BOOL CHXFileSpecUtils::MakeNameLegal(char *pszName)
{
	const char *badChars = ":";
	const char replacementChar = '-';
	const long maxNameLength = 31;

	long len, idx;
	BOOL bChanged;
	
	require_nonnull_return(pszName, FALSE);
	
	bChanged = FALSE;
	
	len = strlen(pszName);
	
	// replace any illegal characters
	for (idx = 0; idx < len; idx++)
	{
		if (strchr(badChars, pszName[idx]))
		{
			pszName[idx] = replacementChar;
			bChanged = TRUE;
		}
	}
	
	// be sure the name isn't too long
	if (len > maxNameLength)
	{
		pszName[maxNameLength] = 0;
		bChanged = TRUE;
	}
	
	return bChanged;
}


// ------------------------------------------------------------------------------------
//
// FindFolder
//
// ------------------------------------------------------------------------------------

CHXDirSpecifier CHXFileSpecUtils::MacFindFolder(short vRefNum, FolderType foldType)
{
	short 				foundVRefNum;
	long 				foundDirID;
	FSSpec				targetSpec;
	CHXDirSpecifier		foundDirSpec;
	OSErr				err;
	
	err = ::FindFolder(vRefNum, foldType, kCreateFolder, &foundVRefNum, &foundDirID);
	if (err == noErr)
	{
		err = FSMakeFSSpec(foundVRefNum, foundDirID, "\p", &targetSpec);
		check_noerr(err);
		if (err == noErr)
		{
			foundDirSpec = targetSpec;
		}
	}
	
	return foundDirSpec;
}

CHXFileSpecifier CHXFileSpecUtils::SpecifyFileWithMacFindFolder(short vRefNum, FolderType foldType, const char *pszChildFile)
{
	CHXDirSpecifier parentDir;
	CHXFileSpecifier targetFile;
	
	parentDir = CHXFileSpecUtils::MacFindFolder(vRefNum, foldType);
	check(parentDir.IsSet());
	
	if (CHXFileSpecUtils::DirectoryExists(parentDir))
	{
		targetFile = parentDir.SpecifyChildFile(pszChildFile);
	}
	
	return targetFile;
}

CHXDirSpecifier CHXFileSpecUtils::SpecifyFolderWithMacFindFolder(short vRefNum, FolderType foldType, const char *pszChildFolder)
{
	CHXDirSpecifier parentDir;
	CHXDirSpecifier targetDir;
	
	parentDir = CHXFileSpecUtils::MacFindFolder(vRefNum, foldType);
	check(parentDir.IsSet());
	
	if (CHXFileSpecUtils::DirectoryExists(parentDir))
	{
		targetDir = parentDir.SpecifyChildDirectory(pszChildFolder);
	}
	
	return targetDir;
}

// ------------------------------------------------------------------------------------
//
// ResolveFileSpecifierAlias
// ResolveDirSpecifierAlias
//
// These resolve a file spec to an alias file in place
//
// ------------------------------------------------------------------------------------

HX_RESULT CHXFileSpecUtils::ResolveFileSpecifierAlias(CHXFileSpecifier& fileSpec)
{
	HX_RESULT res;