FileUtils.h

//========================================================================================
// 
// $File$
// 
// Owner: Robin_Briggs
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// ADOBE CONFIDENTIAL
// 
//========================================================================================

#ifndef __FileUtils__
#define __FileUtils__

class IPMStream;
class PMString;
class SysFileList;
#include <string>
#include <vector>
#include "AppInfo.h"
#include "LocaleSetting.h"

#if defined(WINDOWS) || defined(WASM)
 enum CFURLPathStyle { 
 kCFURLPOSIXPathStyle = 0,
 kCFURLHFSPathStyle = 1, // Deprecated: Use kCFURLPOSIXPathStyle instead. 
 // Note: Special handling exists in URLUtils.cpp for host names (like localhost)
 // where kCFURLHFSPathStyle was previously used to correctly handle volume names.
 kCFURLWindowsPathStyle = 2
 };
#endif

class FileUtils {
public:
#ifdef DEBUG
 // in a debug build, get the path to a file in the QA:Logs: folder.
 // will create the QA and Logs folders if none exist.
 static PMString GetLogFilePath(const PMString& fileName);
#endif
 // returns the directory seperator for the system
 static char GetDirectorySeperator();
 // Set the application directory.
 static bool16 SetAppFolder(SysConnection appResourceHandle = nil);
 // Return the file descriptor of the application directory
 static bool16 GetAppFolder(IDFile *appFolder);
 // Return the pathname for the application directory.
 static bool16 GetAppFolder(PMString *appFolder);
 // Return the full path for the application.
 static bool16 GetAppPath(IDFile *appPath);
 // Find a specified sub-folder of the application folder. 
 // Sub-folder is specified by name.
 // NOTE! This function will return kTrue with a valid IDFile even
 // if the folder does not exist. It does not create the sub-folder for you.
 static bool16 GetAppSubFolder(IDFile *result, const PMString& subFolderName);
 // Return the current user's roaming directory with appended folder paths. It wont create the folder if it doesnt exist
 static bool16 GetUserRoamingFolder(IDFile *result, const PMString& appFolder, const PMString& subFolderName);

 static bool16 GetAppLocalCachedDataFolder(IDFile *result, const PMString& subFolderName);

 static bool16 GetAppRoamingDataFolder(IDFile *result, const PMString& subFolderName);

 // Find a specified sub-folder of the application document folder. 
 // Sub-folder is specified by name. User's unnamed files go here.
 static bool16 GetAppDocumentFolder(IDFile *result, const PMString& subFolderName);
 // Find a specified sub-folder of the application document folder. 
 // Sub-folder is specified by name. The Recovery directory goes here
 static bool16 GetRecoveryFolder(IDFile *result, const PMString& subFolderName);
 // Find a specified sub-folder of the user dictionaries folder. 
 // Creates the folder if it doesn't already exist.
 // Sub-folder is specified by name. The user dictionaries files go here.
 static bool16 GetUserDictionariesFolder(IDFile *result, const PMString& subFolderName);

 // Set the current working directory to the target file descriptor
 static bool16 SetCurrentFolder(const IDFile& targetFolder);
 // Return the file descriptor of the current working directory
 static bool16 GetCurrentFolder(IDFile *currentFolder);

 // Append pathToAppend onto the end of originalPath.
 static void AppendPath(IDFile *originalPath, const PMString& pathToAppend);
 // Get the filename out of the IDFile.
 static void GetFileName(const IDFile& fSpec, PMString& fileName);
 static void GetFileName(const PMString& pathStr, PMString& fileName);

 // Compare the two file names for equality.
 static bool16 IsEqual(const IDFile& file1, const IDFile& file2);
 
 // Does not actually swap the files, but simply moves file1 to file2. Returns false if operation fails.
 static bool SwapFiles(const IDFile& file1, const IDFile& file2);
 
 static void IDFileToPMString(const IDFile& file, PMString& pathStr);
 
 static void PMStringToIDFile(const PMString& pathStr, IDFile& file);

 static PMString SysFileToPMString(const IDFile& file);

 static IDFile PMStringToSysFile(const PMString& pathStr);
 
 static PMString SysFileToFileURL(const IDFile& fSpec);
 
 static PMString PMStringToFileURL(const PMString& fileName);

 static PMString PMStringToURL(const PMString& str);

 static PMString URLToPMString (const std::string &URL);
 
 static std::string UTF8ToURL(const std::string& str, const char kSeparator);
 
 static std::string URLToUTF8 (const std::string& fileURL, bool & ContainsUTF16);

 static PMString FileURLToPMString (const std::string &fileURL);
 
 static PMString FileURLToPMString (const PMString &__fileURL);

 static IDFile FileURLToSysFile(const std::string& __fileURL, bool *isReturingAValidSysFile = NULL);
 
 static IDFile FileURLToSysFile(const PMString & __fileURL, bool *isReturingAValidSysFile = NULL);
 
 // If pathName is a relative path, it is resolved into a full path,
 // based on the application directory. Indirection to parent folder
 // (UNIX "..") is not supported. If the path is already fully resolved,
 // returns nil.
 static PMString *CreateResolvedPathName(const PMString& pathName);
 
 // Returns the amount of free space in K, on the volume or disk
 // that holds the specified directory.
 static uint32 SpaceAvail(const IDFile& diskToCheck);
 
 static bool16 IsDirectory(const IDFile& fileSpec);

 static bool16 CreateFolderIfNeeded(const IDFile& folderFileSpec, bool16 bCreateParent = kFalse);
 static bool16 CopyFile(const IDFile& srcFile, const IDFile& dstFile); 
 static bool16 MoveFile(const IDFile& srcFile, const IDFile& dstFolder, IDFile* dstFile = NULL); 
 static bool16 GetParentDirectory(IDFile const &file, IDFile &parent);
 static bool16 DoesFileExist(const IDFile& fileSpec);
 // get the path, without the filename
 static void GetPathOnly(const IDFile& fileSpec, PMString& pathName, bool16 includeSeparator = kFalse);
 //get the filename, minus any extension
 static void GetBaseFileName(const IDFile& inFile, PMString& outString);
 static void GetBaseFileName(const PMString& inString, PMString& outString);
 // Kinda the opposite of GetBaseFileName - returns only the extension
 static void GetExtension(const IDFile& inFile, PMString& outString);
 
 //ResourceFork deprecated, function returns data fork size
 static uint32 GetFileSize(const IDFile& fileSpec, bool16 includeResourceFork = kFalse);


 // This function returns the file type(pub, template, book, library etc.) based on the passed in sysFile.
 static bool16 GetOpenFileType(const IDFile& sysFile, SysFileType &type);

 // This function is like the one above, but takes an open stream as its input.
 static bool16 GetStreamFileType(IPMStream *stream, SysFileType &type);
 
 // Get the name of the volume the file or folder is on.
 static void GetVolumeName(const IDFile *fileOrFolderSpec, PMString * volumeName);

 // Compare the two file names for same volume.
 static bool16 OnSameVolume(const IDFile& file1, const IDFile& file2);

 static int32 ShowFile( const IDFile& fileSpec);
 
 typedef enum { kNormal, kOpenNewWindow, kOpenMaximized } ViewMode;
 static ErrorCode BrowseToFile(const IDFile *fileSpec, ViewMode mode = kNormal);
 static ErrorCode OpenFileInEditor(const IDFile& fileToOpen, const AppInfo& appInfo = kNullAppInfo, PMString *errorString = nil);

 static bool16 IsNetworkDrive( const IDFile& sysFile );
 
 // Return the directory where app is installed by user. It should return the same folder as 
 // GetAppFolder on WINDOWS. On MACINTOSH, it should return the folder three level above the 
 // real application file due to mac package folder structure.
 static bool16 GetAppInstallationFolder(IDFile *folder);
 
 static bool16 GetPresetsFolder(IDFile *folder, const PMString& subFolderName, const PMLocaleId& localeId);

 static void AppendLocalizedFolder(IDFile* folder, const PMLocaleId& localeId);

 // NOTE: Just moved this out of the #ifdef MAC section, and put a Windows impl in
 static bool16 GetModificationDate(const IDFile & spec, uint32 *modDate);

 // Return kTrue if the file can be opened with the requested access rights.
 typedef enum { kRead, kWrite, kReadWrite } Access;
 static bool8 CanOpen(const IDFile& spec, Access access = kReadWrite);

 static void PrefixFileURL (const PMString &prefix, PMString &fileURL);

 static FILE* OpenFile(const IDFile& file, const char* mode);
 
 static FILE* OpenFile(const PMString& path, const char* mode);
 
 static FILE* OpenFile(const char* path, const char* mode);
 
#ifdef MACINTOSH 

 // Append pathToAppend onto the end of originalPath.
 static void AppendPath(PMString *originalPath, const PMString& pathToAppend);
 
 // Get the dirID of the folder
 static bool16 GetDirID(const IDFile& folder, int32* dirID);

 static void ReplaceResource(SysHandle rsrc, int32 type, int16 id, const PMString& name);
 
 static void GetFileCreatorType(const IDFile& fileSpec, SysOSType* fileType, SysOSType* creator);
 static bool16 GetCreationDate(const IDFile & spec, uint32 *creDate);
 
 // Return the directory where application package is located. It should be two level above the 
 // real application file due to mac package folder structure.
 static bool16 GetPackageFolder(IDFile *folder);
 
 // Create the file using the Unicode file name in the IDFile.
 // Set bCreateParent to kTrue to create parent folders if necessary.
 // If the file cannot be created or already exists, the method returns kFalse.
 static bool16 CreateFileWithUnicodeName(IDFile& fileSpec, bool16 bCreateParent = kFalse);
 
 static std::string FileURLToPosixPath (const std::string& fileURL) ;
 
 static PMString DecomposeUnicode (const PMString &str);
 
 static void NormalizeUnComposedUnicodeChars (PMString &fileName);

 static IDFile PosixPathToSysFile(const PMString& posixPath);
 static IDFile PosixPathToSysFile(const std::string& posixPath);

 static OSErr FSRefToIDFile(const FSRef& fsRef, IDFile& file);

 static OSErr IDFileToFSRef(const IDFile& file, FSRef& fsRef);
 
 static bool16 IsFileInTrash(const IDFile& file);
 
 static OSErr GetURLAppleEventDescFromCFURL(AEDesc* fURLDesc, CFURLRef url);

 /*
 Decodes an Apple event descriptor record
 @param aeDes IN AEDesc the input Apple Event descriptor to decode
 @return CFURLRef on success, NULL if any error occurs.
 Caller needs to release the CFURLRef
 */
 static CFURLRef CreateCFURLFromURLAppleEventDesc(const AEDesc* aeDesc);

#endif

#ifdef WINDOWS
 // Windows edge code for implementing common dialog that checks
 // for filenames with bad characters

 static IDThreading::ThreadLocal<DWORD> tl_GOFNCallerFlags;
 static IDThreading::ThreadLocal<LPOFNHOOKPROC> tl_GOFNCallerHookProc;
 static IDThreading::ThreadLocal<LPOPENFILENAME> tl_GOFNCallerlpofn;

 // Hook function used by FileUtils::GetOpenFileName()
 static UINT_PTR APIENTRY GOFNHookFunction(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam);

 // Same as ::GetOpenFileName() but catches files with bad names and warns user
 // Uses the AWS GetFileDialog() GUI if AWS is defined and will load the given
 // SysFileList with the result files
 // K2 should use this call in preference to Win32 API ::GetOpenFileName()
 static bool16 GetOpenFileName(LPOPENFILENAME lpofn);
 static bool16 GetOpenFileName(LPOPENFILENAME lpofn, SysFileList& resultFiles);
 static bool16 GetOpenFileName(LPOPENFILENAME lpofn, SysFileList* pResultFiles);

 static int32 CoverSHGetFolderPath(int nFolder, IDFile *path);
#endif

#ifdef WASM

 static bool16 GetAppTmpFolder(IDFile *result, const PMString& subFolderName);
#endif

 /*
 Query if preferences folder was created in current app launch
 @return kFalse, if the roaming data folder existed before app launch, kTrue otherwise
 */
 static bool16 IsAppRoamingDataFolderNew();

 static bool16 GetAppLocalCachedDataFolderSansLocale(IDFile *result);

 static textchar GetDirectorySeparatorTextChar();

 static bool16 IsTemplate(const IDFile & file);

 static bool16 IsTempFile(const IDFile & file);

#ifdef MACINTOSH

 static void IDFileToPMStringBasedOnPathString(const IDFile& file, PMString& pathStr);
#endif

 static void CreateUniqueFileName(PMString & fileName);


#ifdef WINDOWS

 static void IDFileToPMStringWithUNCConversion(const IDFile& file, PMString& pathStr);

 typedef enum { kSystemPath, kWindowsPath } DirPath;
 static HMODULE LoadLibraryUsingAbsolutePath(const std::wstring& componentName, DirPath dirPath = kSystemPath);
#endif

 static IDataBase::DBResultCode CheckFileAccessibleForSaving(const IDFile& destFile);

 static PMString GetDirectorySeparatorPMString();

 static void AppendPaths(IDFile *originalPath, const std::vector<PMString> &pathsToAppend);
 
 static void AppendPaths(IDFile *originalPath, const std::vector<const wchar_t*> &pathsToAppend);

 // Posix directory seperator

 static char GetPosixDirectorySeparator();

 static textchar GetPosixDirectorySeparatorTextChar();

 static PMString GetPosixDirectorySeparatorPMString();

 static CFURLPathStyle GetMacPathStyle();

 static char GetMacDirectorySeparator();

 static textchar GetMacDirectorySeparatorTextChar();

 static PMString GetMacDirectorySeparatorPMString();

#ifdef MACINTOSH
 // HFS <-> Posix conversion API's

 static void HFSPathToPOSIXPath(const PMString &hfsPath, PMString &posixPath);

 static void HFSPathToPOSIXPath(const std::string &hfsPath, std::string &posixPath);

 static void POSIXPathToHFSPath(const PMString &posixPath, PMString &hfsPath);

 static void POSIXPathToHFSPath(const std::string &posixPath, std::string &hfsPath);

 static void AppendPaths(PMString *originalPath, const std::vector<const PMString> &pathsToAppend);

 static void AppendPaths(PMString *originalPath, const std::vector<const wchar_t*> &pathsToAppend);

#endif
private :
 
 
 
 static std::string FileURLToUTF8Path (const std::string& fileURL, const char kSeperator, bool & ContainsUTF16);
 
 static int16 GetHexChar (const std::string & string, int index);

 static bool16 IsFirstFilePrefixOfSecond(const IDFile & firstFile, const IDFile & secondFile);
};

#endif