多媒体编程

开发平台：

Visual C++

Files.h：源码内容

#endif
EXTERN_API( OSErr ) PBGetAltAccessSync(HParmBlkPtr paramBlock) TWOWORDINLINE(0x7060, 0xA060);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetAltAccessAsync(__A0)
#endif
EXTERN_API( OSErr ) PBGetAltAccessAsync(HParmBlkPtr paramBlock) TWOWORDINLINE(0x7060, 0xA460);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBSetAltAccessSync(__A0)
#endif
EXTERN_API( OSErr ) PBSetAltAccessSync(HParmBlkPtr paramBlock) TWOWORDINLINE(0x7061, 0xA060);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBSetAltAccessAsync(__A0)
#endif
EXTERN_API( OSErr ) PBSetAltAccessAsync(HParmBlkPtr paramBlock) TWOWORDINLINE(0x7061, 0xA460);
#endif /* CALL_NOT_IN_CARBON */
#define PBSetAltAccess(pb, async) ((async) ? PBSetAltAccessAsync(pb) : PBSetAltAccessSync(pb))
#define PBGetAltAccess(pb, async) ((async) ? PBGetAltAccessAsync(pb) : PBGetAltAccessSync(pb))
#endif /* TARGET_CPU_68K */
/*
The PBxxx() routines are obsolete.
Use the PBxxxSync() or PBxxxAsync() version instead.
*/
#define PBGetVInfo(pb, async) ((async) ? PBGetVInfoAsync(pb) : PBGetVInfoSync(pb))
#define PBXGetVolInfo(pb, async) ((async) ? PBXGetVolInfoAsync(pb) : PBXGetVolInfoSync(pb))
#define PBGetVol(pb, async) ((async) ? PBGetVolAsync(pb) : PBGetVolSync(pb))
#define PBSetVol(pb, async) ((async) ? PBSetVolAsync(pb) : PBSetVolSync(pb))
#define PBFlushVol(pb, async) ((async) ? PBFlushVolAsync(pb) : PBFlushVolSync(pb))
#define PBCreate(pb, async) ((async) ? PBCreateAsync(pb) : PBCreateSync(pb))
#define PBDelete(pb, async) ((async) ? PBDeleteAsync(pb) : PBDeleteSync(pb))
#define PBOpenDF(pb, async) ((async) ? PBOpenDFAsync(pb) : PBOpenDFSync(pb))
#define PBOpenRF(pb, async) ((async) ? PBOpenRFAsync(pb) : PBOpenRFSync(pb))
#define PBRename(pb, async) ((async) ? PBRenameAsync(pb) : PBRenameSync(pb))
#define PBGetFInfo(pb, async) ((async) ? PBGetFInfoAsync(pb) : PBGetFInfoSync(pb))
#define PBSetFInfo(pb, async) ((async) ? PBSetFInfoAsync(pb) : PBSetFInfoSync(pb))
#define PBSetFLock(pb, async) ((async) ? PBSetFLockAsync(pb) : PBSetFLockSync(pb))
#define PBRstFLock(pb, async) ((async) ? PBRstFLockAsync(pb) : PBRstFLockSync(pb))
#define PBSetFVers(pb, async) ((async) ? PBSetFVersAsync(pb) : PBSetFVersSync(pb))
#define PBAllocate(pb, async) ((async) ? PBAllocateAsync(pb) : PBAllocateSync(pb))
#define PBGetEOF(pb, async) ((async) ? PBGetEOFAsync(pb) : PBGetEOFSync(pb))
#define PBSetEOF(pb, async) ((async) ? PBSetEOFAsync(pb) : PBSetEOFSync(pb))
#define PBGetFPos(pb, async) ((async) ? PBGetFPosAsync(pb) : PBGetFPosSync(pb))
#define PBSetFPos(pb, async) ((async) ? PBSetFPosAsync(pb) : PBSetFPosSync(pb))
#define PBFlushFile(pb, async) ((async) ? PBFlushFileAsync(pb) : PBFlushFileSync(pb))
#define PBCatSearch(pb, async) ((async) ? PBCatSearchAsync(pb) : PBCatSearchSync(pb))
#define PBOpenWD(pb, async) ((async) ? PBOpenWDAsync(pb) : PBOpenWDSync(pb))
#define PBCloseWD(pb, async) ((async) ? PBCloseWDAsync(pb) : PBCloseWDSync(pb))
#define PBHSetVol(pb, async) ((async) ? PBHSetVolAsync(pb) : PBHSetVolSync(pb))
#define PBHGetVol(pb, async) ((async) ? PBHGetVolAsync(pb) : PBHGetVolSync(pb))
#define PBCatMove(pb, async) ((async) ? PBCatMoveAsync(pb) : PBCatMoveSync(pb))
#define PBDirCreate(pb, async) ((async) ? PBDirCreateAsync(pb) : PBDirCreateSync(pb))
#define PBGetWDInfo(pb, async) ((async) ? PBGetWDInfoAsync(pb) : PBGetWDInfoSync(pb))
#define PBGetFCBInfo(pb, async) ((async) ? PBGetFCBInfoAsync(pb) : PBGetFCBInfoSync(pb))
#define PBGetCatInfo(pb, async) ((async) ? PBGetCatInfoAsync(pb) : PBGetCatInfoSync(pb))
#define PBSetCatInfo(pb, async) ((async) ? PBSetCatInfoAsync(pb) : PBSetCatInfoSync(pb))
#define PBAllocContig(pb, async) ((async) ? PBAllocContigAsync(pb) : PBAllocContigSync(pb))
#define PBLockRange(pb, async) ((async) ? PBLockRangeAsync(pb) : PBLockRangeSync(pb))
#define PBUnlockRange(pb, async) ((async) ? PBUnlockRangeAsync(pb) : PBUnlockRangeSync(pb))
#define PBSetVInfo(pb, async) ((async) ? PBSetVInfoAsync(pb) : PBSetVInfoSync(pb))
#define PBHGetVInfo(pb, async) ((async) ? PBHGetVInfoAsync(pb) : PBHGetVInfoSync(pb))
#define PBHOpen(pb, async) ((async) ? PBHOpenAsync(pb) : PBHOpenSync(pb))
#define PBHOpenRF(pb, async) ((async) ? PBHOpenRFAsync(pb) : PBHOpenRFSync(pb))
#define PBHOpenDF(pb, async) ((async) ? PBHOpenDFAsync(pb) : PBHOpenDFSync(pb))
#define PBHCreate(pb, async) ((async) ? PBHCreateAsync(pb) : PBHCreateSync(pb))
#define PBHDelete(pb, async) ((async) ? PBHDeleteAsync(pb) : PBHDeleteSync(pb))
#define PBHRename(pb, async) ((async) ? PBHRenameAsync(pb) : PBHRenameSync(pb))
#define PBHRstFLock(pb, async) ((async) ? PBHRstFLockAsync(pb) : PBHRstFLockSync(pb))
#define PBHSetFLock(pb, async) ((async) ? PBHSetFLockAsync(pb) : PBHSetFLockSync(pb))
#define PBHGetFInfo(pb, async) ((async) ? PBHGetFInfoAsync(pb) : PBHGetFInfoSync(pb))
#define PBHSetFInfo(pb, async) ((async) ? PBHSetFInfoAsync(pb) : PBHSetFInfoSync(pb))
#define PBMakeFSSpec(pb, async) ((async) ? PBMakeFSSpecAsync(pb) : PBMakeFSSpecSync(pb))
#define PBHGetVolParms(pb, async) ((async) ? PBHGetVolParmsAsync(pb) : PBHGetVolParmsSync(pb))
#define PBHGetLogInInfo(pb, async) ((async) ? PBHGetLogInInfoAsync(pb) : PBHGetLogInInfoSync(pb))
#define PBHGetDirAccess(pb, async) ((async) ? PBHGetDirAccessAsync(pb) : PBHGetDirAccessSync(pb))
#define PBHSetDirAccess(pb, async) ((async) ? PBHSetDirAccessAsync(pb) : PBHSetDirAccessSync(pb))
#define PBHMapID(pb, async) ((async) ? PBHMapIDAsync(pb) : PBHMapIDSync(pb))
#define PBHMapName(pb, async) ((async) ? PBHMapNameAsync(pb) : PBHMapNameSync(pb))
#define PBHCopyFile(pb, async) ((async) ? PBHCopyFileAsync(pb) : PBHCopyFileSync(pb))
#define PBHMoveRename(pb, async) ((async) ? PBHMoveRenameAsync(pb) : PBHMoveRenameSync(pb))
#define PBHOpenDeny(pb, async) ((async) ? PBHOpenDenyAsync(pb) : PBHOpenDenySync(pb))
#define PBHOpenRFDeny(pb, async) ((async) ? PBHOpenRFDenyAsync(pb) : PBHOpenRFDenySync(pb))
#define PBExchangeFiles(pb, async) ((async) ? PBExchangeFilesAsync(pb) : PBExchangeFilesSync(pb))
#define PBCreateFileIDRef(pb, async) ((async) ? PBCreateFileIDRefAsync(pb) : PBCreateFileIDRefSync(pb))
#define PBResolveFileIDRef(pb, async) ((async) ? PBResolveFileIDRefAsync(pb) : PBResolveFileIDRefSync(pb))
#define PBDeleteFileIDRef(pb, async) ((async) ? PBDeleteFileIDRefAsync(pb) : PBDeleteFileIDRefSync(pb))
#define PBGetForeignPrivs(pb, async) ((async) ? PBGetForeignPrivsAsync(pb) : PBGetForeignPrivsSync(pb))
#define PBSetForeignPrivs(pb, async) ((async) ? PBSetForeignPrivsAsync(pb) : PBSetForeignPrivsSync(pb))
#define PBDTAddIcon(pb, async) ((async) ? PBDTAddIconAsync(pb) : PBDTAddIconSync(pb))
#define PBDTGetIcon(pb, async) ((async) ? PBDTGetIconAsync(pb) : PBDTGetIconSync(pb))
#define PBDTGetIconInfo(pb, async) ((async) ? PBDTGetIconInfoAsync(pb) : PBDTGetIconInfoSync(pb))
#define PBDTAddAPPL(pb, async) ((async) ? PBDTAddAPPLAsync(pb) : PBDTAddAPPLSync(pb))
#define PBDTRemoveAPPL(pb, async) ((async) ? PBDTRemoveAPPLAsync(pb) : PBDTRemoveAPPLSync(pb))
#define PBDTGetAPPL(pb, async) ((async) ? PBDTGetAPPLAsync(pb) : PBDTGetAPPLSync(pb))
#define PBDTSetComment(pb, async) ((async) ? PBDTSetCommentAsync(pb) : PBDTSetCommentSync(pb))
#define PBDTRemoveComment(pb, async) ((async) ? PBDTRemoveCommentAsync(pb) : PBDTRemoveCommentSync(pb))
#define PBDTGetComment(pb, async) ((async) ? PBDTGetCommentAsync(pb) : PBDTGetCommentSync(pb))
#define PBDTFlush(pb, async) ((async) ? PBDTFlushAsync(pb) : PBDTFlushSync(pb))
#define PBDTReset(pb, async) ((async) ? PBDTResetAsync(pb) : PBDTResetSync(pb))
#define PBDTGetInfo(pb, async) ((async) ? PBDTGetInfoAsync(pb) : PBDTGetInfoSync(pb))
#define PBDTDelete(pb, async) ((async) ? PBDTDeleteAsync(pb) : PBDTDeleteSync(pb))
typedef SInt16 FSVolumeRefNum;
enum {
kFSInvalidVolumeRefNum = 0
};
#if TARGET_OS_WIN32
struct FSRef {
UInt8 hidden[600]; /* private to File Manager; oo need symbolic constant */
};
typedef struct FSRef FSRef;
#else
struct FSRef {
UInt8 hidden[80]; /* private to File Manager; oo need symbolic constant */
};
typedef struct FSRef FSRef;
#endif /* TARGET_OS_WIN32 */
typedef FSRef * FSRefPtr;
/* CatalogInfoBitmap describes which fields of the CatalogInfo you wish to get or set.*/
typedef UInt32 FSCatalogInfoBitmap;
enum {
kFSCatInfoNone = 0x00000000,
kFSCatInfoTextEncoding = 0x00000001,
kFSCatInfoNodeFlags = 0x00000002, /* Locked (bit 0) and directory (bit 4) only */
kFSCatInfoVolume = 0x00000004,
kFSCatInfoParentDirID = 0x00000008,
kFSCatInfoNodeID = 0x00000010,
kFSCatInfoCreateDate = 0x00000020,
kFSCatInfoContentMod = 0x00000040,
kFSCatInfoAttrMod = 0x00000080,
kFSCatInfoAccessDate = 0x00000100,
kFSCatInfoBackupDate = 0x00000200,
kFSCatInfoPermissions = 0x00000400, /* Should this be finer granularity? */
kFSCatInfoFinderInfo = 0x00000800,
kFSCatInfoFinderXInfo = 0x00001000,
kFSCatInfoValence = 0x00002000, /* Folders only, zero for files */
kFSCatInfoDataSizes = 0x00004000, /* Data fork logical and physical size */
kFSCatInfoRsrcSizes = 0x00008000, /* Resource fork logical and physical size */
kFSCatInfoSharingFlags = 0x00010000, /* sharingFlags: kioFlAttribMountedBit, kioFlAttribSharePointBit */
kFSCatInfoUserPrivs = 0x00020000, /* userPrivileges */
kFSCatInfoAllDates = 0x000003E0,
kFSCatInfoGettableInfo = 0x0003FFFF,
kFSCatInfoSettableInfo = 0x00001FE3, /* flags, dates, permissions, Finder info, text encoding */
kFSCatInfoReserved = (long)0xFFFC0000 /* bits that are currently reserved */
};
/* Constants for nodeFlags field of FSCatalogInfo*/
enum {
kFSNodeLockedBit = 0,
kFSNodeLockedMask = 0x0001,
kFSNodeIsDirectoryBit = 4,
kFSNodeIsDirectoryMask = 0x0010
};
struct FSCatalogInfo {
UInt16 nodeFlags; /* node flags */
FSVolumeRefNum volume; /* object's volume ref */
UInt32 parentDirID; /* parent directory's ID */
UInt32 nodeID; /* file/directory ID */
UInt8 sharingFlags; /* kioFlAttribMountedBit and kioFlAttribSharePointBit */
UInt8 userPrivileges; /* user's effective AFP privileges (same as ioACUser) */
UInt8 reserved1;
UInt8 reserved2;
UTCDateTime createDate; /* date and time of creation */
UTCDateTime contentModDate; /* date and time of last fork modification */
UTCDateTime attributeModDate; /* date and time of last attribute modification */
UTCDateTime accessDate; /* date and time of last access (for Mac OS X) */
UTCDateTime backupDate; /* date and time of last backup */
UInt32 permissions[4]; /* permissions (for Mac OS X) */
UInt8 finderInfo[16]; /* Finder information part 1 */
UInt8 extFinderInfo[16]; /* Finder information part 2 */
UInt64 dataLogicalSize; /* files only */
UInt64 dataPhysicalSize; /* files only */
UInt64 rsrcLogicalSize; /* files only */
UInt64 rsrcPhysicalSize; /* files only */
UInt32 valence; /* folders only */
TextEncoding textEncodingHint;
};
typedef struct FSCatalogInfo FSCatalogInfo;
typedef FSCatalogInfo * FSCatalogInfoPtr;
struct FSRefParam {
QElemPtr qLink; /*queue link in header*/
short qType; /*type byte for safety check*/
short ioTrap; /*FS: the Trap*/
Ptr ioCmdAddr; /*FS: address to dispatch to*/
IOCompletionUPP ioCompletion; /*completion routine addr (0 for synch calls)*/
volatile OSErr ioResult; /*result code*/
ConstStringPtr ioNamePtr; /*ptr to Vol:FileName string*/
short ioVRefNum; /*volume refnum (DrvNum for Eject and MountVol)*/
SInt16 reserved1; /* was ioRefNum */
UInt8 reserved2; /* was ioVersNum */
UInt8 reserved3; /* was ioPermssn */
const FSRef * ref; /* Input ref; the target of the call */
FSCatalogInfoBitmap whichInfo;
FSCatalogInfo * catInfo;
UniCharCount nameLength; /* input name length for create/rename */
const UniChar * name; /* input name for create/rename */
long ioDirID;
FSSpec * spec;
FSRef * parentRef; /* ref of directory to move another ref to */
FSRef * newRef; /* Output ref */
TextEncoding textEncodingHint; /* for Rename, MakeFSRefUnicode */
HFSUniStr255 * outName; /* Output name for GetCatalogInfo */
};
typedef struct FSRefParam FSRefParam;
typedef FSRefParam * FSRefParamPtr;
typedef struct OpaqueFSIterator* FSIterator;
enum {
kFSIterateFlat = 0, /* Immediate children of container only */
kFSIterateSubtree = 1, /* Entire subtree rooted at container */
kFSIterateReserved = (long)0xFFFFFFFE
};
typedef OptionBits FSIteratorFlags;
enum {
/* CatalogSearch constants */
fsSBNodeID = 0x00008000, /* search by range of nodeID */
fsSBAttributeModDate = 0x00010000, /* search by range of attributeModDate */
fsSBAccessDate = 0x00020000, /* search by range of accessDate */
fsSBPermissions = 0x00040000, /* search by value/mask of permissions */
fsSBNodeIDBit = 15,
fsSBAttributeModDateBit = 16,
fsSBAccessDateBit = 17,
fsSBPermissionsBit = 18
};
struct FSSearchParams {
Duration searchTime; /* a Time Manager duration */
OptionBits searchBits; /* which fields to search on */
UniCharCount searchNameLength;
const UniChar * searchName;
FSCatalogInfo * searchInfo1; /* values and lower bounds */
FSCatalogInfo * searchInfo2; /* masks and upper bounds */
};
typedef struct FSSearchParams FSSearchParams;
typedef FSSearchParams * FSSearchParamsPtr;
struct FSCatalogBulkParam {
QElemPtr qLink; /*queue link in header*/
short qType; /*type byte for safety check*/
short ioTrap; /*FS: the Trap*/
Ptr ioCmdAddr; /*FS: address to dispatch to*/
IOCompletionUPP ioCompletion; /*completion routine addr (0 for synch calls)*/
volatile OSErr ioResult; /*result code*/
Boolean containerChanged; /* true if container changed since last iteration */
UInt8 reserved; /* make following fields 4-byte aligned */
FSIteratorFlags iteratorFlags;
FSIterator iterator;
const FSRef * container; /* directory/volume to iterate */
ItemCount maximumItems;
ItemCount actualItems;
FSCatalogInfoBitmap whichInfo;
FSCatalogInfo * catalogInfo; /* returns an array */
FSRef * refs; /* returns an array */
FSSpec * specs; /* returns an array */
HFSUniStr255 * names; /* returns an array */
const FSSearchParams * searchParams;
};
typedef struct FSCatalogBulkParam FSCatalogBulkParam;
typedef FSCatalogBulkParam * FSCatalogBulkParamPtr;
typedef UInt16 FSAllocationFlags;
enum {
kFSAllocDefaultFlags = 0x0000, /* as much as possible, not contiguous */
kFSAllocAllOrNothingMask = 0x0001, /* allocate all of the space, or nothing */
kFSAllocContiguousMask = 0x0002, /* new space must be one contiguous piece */
kFSAllocNoRoundUpMask = 0x0004, /* don't round up allocation to clump size */
kFSAllocReservedMask = 0xFFF8 /* these bits are reserved and must not be set */
};
struct FSForkIOParam {
QElemPtr qLink; /*queue link in header*/
short qType; /*type byte for safety check*/
short ioTrap; /*FS: the Trap*/
Ptr ioCmdAddr; /*FS: address to dispatch to*/
IOCompletionUPP ioCompletion; /*completion routine addr (0 for synch calls)*/
volatile OSErr ioResult; /*result code*/
void * reserved1; /* was ioNamePtr */
SInt16 reserved2; /* was ioVRefNum */
SInt16 forkRefNum; /* same as ioRefNum */
UInt8 reserved3; /* was ioVersNum */
SInt8 permissions; /* desired access to the fork */
const FSRef * ref; /* which object to open */
Ptr buffer; /*data buffer Ptr*/
UInt32 requestCount; /*requested byte count*/
UInt32 actualCount; /*actual byte count completed*/
UInt16 positionMode; /*initial file positioning*/
SInt64 positionOffset; /*file position offset*/
FSAllocationFlags allocationFlags;
UInt64 allocationAmount;
UniCharCount forkNameLength; /* input; length of fork name */
const UniChar * forkName; /* input; name of fork */
CatPositionRec forkIterator;
HFSUniStr255 * outForkName; /* output; name of fork */
};
typedef struct FSForkIOParam FSForkIOParam;
typedef FSForkIOParam * FSForkIOParamPtr;
struct FSForkInfo {
SInt8 flags; /* copy of FCB flags */
SInt8 permissions;
FSVolumeRefNum volume;
UInt32 reserved2;
UInt32 nodeID; /* file or directory ID */
UInt32 forkID; /* fork ID */
UInt64 currentPosition;
UInt64 logicalEOF;
UInt64 physicalEOF;
UInt64 process; /* should be ProcessSerialNumber */
};
typedef struct FSForkInfo FSForkInfo;
typedef FSForkInfo * FSForkInfoPtr;
struct FSForkCBInfoParam {
QElemPtr qLink; /*queue link in header*/
short qType; /*type byte for safety check*/
short ioTrap; /*FS: the Trap*/
Ptr ioCmdAddr; /*FS: address to dispatch to*/
IOCompletionUPP ioCompletion; /*completion routine addr (0 for synch calls)*/
volatile OSErr ioResult; /*result code*/
SInt16 desiredRefNum; /* 0 to iterate, non-0 for specific refnum */
SInt16 volumeRefNum; /* volume to match, or 0 for all volumes */
SInt16 iterator; /* 0 to start iteration */
SInt16 actualRefNum; /* actual refnum found */
FSRef * ref;
FSForkInfo * forkInfo;
HFSUniStr255 * forkName;
};
typedef struct FSForkCBInfoParam FSForkCBInfoParam;
typedef FSForkCBInfoParam * FSForkCBInfoParamPtr;
typedef UInt32 FSVolumeInfoBitmap;
enum {
kFSVolInfoNone = 0x0000,
kFSVolInfoCreateDate = 0x0001,
kFSVolInfoModDate = 0x0002,
kFSVolInfoBackupDate = 0x0004,
kFSVolInfoCheckedDate = 0x0008,
kFSVolInfoFileCount = 0x0010,
kFSVolInfoDirCount = 0x0020,
kFSVolInfoSizes = 0x0040, /* totalBytes and freeBytes */
kFSVolInfoBlocks = 0x0080, /* blockSize, totalBlocks, freeBlocks */
kFSVolInfoNextAlloc = 0x0100,
kFSVolInfoRsrcClump = 0x0200,
kFSVolInfoDataClump = 0x0400,
kFSVolInfoNextID = 0x0800,
kFSVolInfoFinderInfo = 0x1000,
kFSVolInfoFlags = 0x2000,
kFSVolInfoFSInfo = 0x4000, /* filesystemID, signature */
kFSVolInfoDriveInfo = 0x8000, /* driveNumber, driverRefNum */
kFSVolInfoGettableInfo = 0xFFFF, /* This seems like it is here just for completeness */
kFSVolInfoSettableInfo = 0x3004 /* backup date, Finder info, flags */
};
struct FSVolumeInfo {
/* Dates -- zero means "never" or "unknown" */
UTCDateTime createDate;
UTCDateTime modifyDate;
UTCDateTime backupDate;
UTCDateTime checkedDate;
/* File/Folder counts -- return zero if unknown */
UInt32 fileCount; /* total files on volume */
UInt32 folderCount; /* total folders on volume */
/* Note: no root directory counts */
UInt64 totalBytes; /* total number of bytes on volume */
UInt64 freeBytes; /* number of free bytes on volume */
/* HFS and HFS Plus specific. Set fields to zero if not appropriate */
UInt32 blockSize; /* size (in bytes) of allocation blocks */
UInt32 totalBlocks; /* number of allocation blocks in volume */
UInt32 freeBlocks; /* number of unused allocation blocks */
UInt32 nextAllocation; /* start of next allocation search */
UInt32 rsrcClumpSize; /* default resource fork clump size */
UInt32 dataClumpSize; /* default data fork clump size */
UInt32 nextCatalogID; /* next unused catalog node ID ooo OYG ooo need to make HFSVolumes.h work Should be HFSCatalogNodeID*/
UInt8 finderInfo[32]; /* information used by Finder */
/* Identifying information */
UInt16 flags; /* ioVAtrb */
UInt16 filesystemID; /* ioVFSID */
UInt16 signature; /* ioVSigWord, unique within an FSID */
UInt16 driveNumber; /* ioVDrvInfo */
short driverRefNum; /* ioVDRefNum */
};
typedef struct FSVolumeInfo FSVolumeInfo;
typedef FSVolumeInfo * FSVolumeInfoPtr;
struct FSVolumeInfoParam {
QElemPtr qLink; /*queue link in header*/
short qType; /*type byte for safety check*/
short ioTrap; /*FS: the Trap*/
Ptr ioCmdAddr; /*FS: address to dispatch to*/
IOCompletionUPP ioCompletion; /*completion routine addr (0 for synch calls)*/
volatile OSErr ioResult; /*result code*/
StringPtr ioNamePtr; /* unused */
FSVolumeRefNum ioVRefNum; /* volume refnum */
UInt32 volumeIndex; /* index, or 0 to use ioVRefNum */
FSVolumeInfoBitmap whichInfo; /* which volumeInfo fields to get/set */
FSVolumeInfo * volumeInfo; /* information about the volume */
HFSUniStr255 * volumeName; /* output; pointer to volume name */
FSRef * ref; /* volume's FSRef */
};
typedef struct FSVolumeInfoParam FSVolumeInfoParam;
typedef FSVolumeInfoParam * FSVolumeInfoParamPtr;
/*
MakeFSRef
Create an FSRef for an existing object specified by a combination
of volume refnum, parent directory, and pathname.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ioNamePtr A pointer to a pathname
-> ioVRefNum A volume specification
-> ioDirID A directory ID
<- newRef A pointer to an FSRef
*/
EXTERN_API( OSErr )
FSpMakeFSRef (const FSSpec * source,
FSRef * newRef) THREEWORDINLINE(0x303C, 0x041A, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBMakeFSRefSync(__A0)
#endif
EXTERN_API( OSErr )
PBMakeFSRefSync (FSRefParam * paramBlock) TWOWORDINLINE(0x706E, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBMakeFSRefAsync(__A0)
#endif
EXTERN_API( void )
PBMakeFSRefAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x706E, 0xA660);
/*
MakeFSRefUnicode
Create an FSRef for an existing object specified by
Parent FSRef and Unicode name.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref A pointer to the parent directory FSRef
-> name A pointer to Unicde name
-> nameLength The length of the Unicode Name
-> textEncodingHint A suggested text encoding to use for the name
<- newRef A pointer to an FSRef
*/
EXTERN_API( OSErr )
FSMakeFSRefUnicode (const FSRef * parentRef,
UniCharCount nameLength,
const UniChar * name,
TextEncoding textEncodingHint,
FSRef * newRef) THREEWORDINLINE(0x303C, 0x0A1B, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBMakeFSRefUnicodeSync(__A0)
#endif
EXTERN_API( OSErr )
PBMakeFSRefUnicodeSync (FSRefParam * paramBlock) TWOWORDINLINE(0x707A, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBMakeFSRefUnicodeAsync(__A0)
#endif
EXTERN_API( void )
PBMakeFSRefUnicodeAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x707A, 0xA660);
/*
CompareFSRefs
Test whether two FSRefs refer to the same file or directory.
If they do, noErr is returned. Otherwise, an appropriate error
(such as errFSRefsDifferent) is returned.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref A pointer to the first FSRef
-> parentRef A pointer to the second FSRef
*/
EXTERN_API( OSErr )
FSCompareFSRefs (const FSRef * ref1,
const FSRef * ref2) THREEWORDINLINE(0x303C, 0x0435, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCompareFSRefsSync(__A0)
#endif
EXTERN_API( OSErr )
PBCompareFSRefsSync (FSRefParam * paramBlock) TWOWORDINLINE(0x707C, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCompareFSRefsAsync(__A0)
#endif
EXTERN_API( void )
PBCompareFSRefsAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x707C, 0xA660);
/*
CreateFileUnicode
Creates a new file. The input filename is in Unicode.
You can optionally set catalog info for the file.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The directory where the file is to be created
-> whichInfo Which catalog info fields to set
-> catInfo The values for catalog info fields to set; may be NULL
-> nameLength Number of Unicode characters in the file's name
-> name A pointer to the Unicode name
<- spec A pointer to the FSSpec for the new directory; may be NULL
<- newRef A pointer to the FSRef for the new file; may be NULL
*/
EXTERN_API( OSErr )
FSCreateFileUnicode (const FSRef * parentRef,
UniCharCount nameLength,
const UniChar * name,
FSCatalogInfoBitmap whichInfo,
const FSCatalogInfo * catalogInfo, /* can be NULL */
FSRef * newRef, /* can be NULL */
FSSpec * newSpec) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0E1C, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCreateFileUnicodeSync(__A0)
#endif
EXTERN_API( OSErr )
PBCreateFileUnicodeSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7070, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCreateFileUnicodeAsync(__A0)
#endif
EXTERN_API( void )
PBCreateFileUnicodeAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7070, 0xA660);
/*
CreateDirectoryUnicode
Creates a new directory. The input directory name is in Unicode.
You can optionally set catalog info for the directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The parent directory where the directory is to be created
-> whichInfo Which catalog info fields to set
-> catInfo The values for catalog info fields to set; may be NULL
-> nameLength Number of Unicode characters in the directory's name
-> name A pointer to the Unicode name
<- ioDirID The DirID of the new directory
<- spec A pointer to the FSSpec for the new directory; may be NULL
<- newRef A pointer to the FSRef for the new directory; may be NULL
*/
EXTERN_API( OSErr )
FSCreateDirectoryUnicode (const FSRef * parentRef,
UniCharCount nameLength,
const UniChar * name,
FSCatalogInfoBitmap whichInfo,
const FSCatalogInfo * catalogInfo, /* can be NULL */
FSRef * newRef, /* can be NULL */
FSSpec * newSpec, /* can be NULL */
UInt32 * newDirID) /* can be NULL */ THREEWORDINLINE(0x303C, 0x101D, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCreateDirectoryUnicodeSync(__A0)
#endif
EXTERN_API( OSErr )
PBCreateDirectoryUnicodeSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7071, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCreateDirectoryUnicodeAsync(__A0)
#endif
EXTERN_API( void )
PBCreateDirectoryUnicodeAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7071, 0xA660);
/*
DeleteObject
Deletes an existing file or directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory to be deleted
*/
EXTERN_API( OSErr )
FSDeleteObject (const FSRef * ref) THREEWORDINLINE(0x303C, 0x021E, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBDeleteObjectSync(__A0)
#endif
EXTERN_API( OSErr )
PBDeleteObjectSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7072, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBDeleteObjectAsync(__A0)
#endif
EXTERN_API( void )
PBDeleteObjectAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7072, 0xA660);
/*
MoveObject
Move an existing file or directory into a different directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory to be moved
-> parentRef The file or directory will be moved into this directory
<- newRef A new FSRef for the file or directory in its new location;
optional, may be NULL
NOTE: Moving an object may change its FSRef. If you want to continue to
refer to the object, you should pass a non-NULL pointer in newRef and use
that returned FSRef to access the object after the move. The FSRef passed
in "ref" may or may not be usable to access the object after it is moved.
"newRef" may point to the same storage as "parentRef" or "ref".
*/
EXTERN_API( OSErr )
FSMoveObject (const FSRef * ref,
const FSRef * destDirectory,
FSRef * newRef) /* can be NULL */ THREEWORDINLINE(0x303C, 0x061F, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBMoveObjectSync(__A0)
#endif
EXTERN_API( OSErr )
PBMoveObjectSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7073, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBMoveObjectAsync(__A0)
#endif
EXTERN_API( void )
PBMoveObjectAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7073, 0xA660);
/*
ExchangeObjects
swap the contents of two files.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The first file
-> parentRef The second file
*/
EXTERN_API( OSErr )
FSExchangeObjects (const FSRef * ref,
const FSRef * destRef) THREEWORDINLINE(0x303C, 0x0421, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBExchangeObjectsSync(__A0)
#endif
EXTERN_API( OSErr )
PBExchangeObjectsSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7075, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBExchangeObjectsAsync(__A0)
#endif
EXTERN_API( void )
PBExchangeObjectsAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7075, 0xA660);
/*
RenameUnicode
Change the name of an existing file or directory. The new name is in
Unicode.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory to be moved
-> nameLength Number of Unicode characters in the new name
-> name A pointer to the new Unicode name
-> textEncodingHint A suggested text encoding to use for the name
<- newRef A new FSRef for the file or directory; may be NULL
NOTE: Renaming an object may change its FSRef. If you want to continue to
refer to the object, you should pass a non-NULL pointer in newRef and use
that returned FSRef to access the object after the rename. The FSRef passed
in "ref" may or may not be usable to access the object after it is renamed.
"newRef" may point to the same storage as "ref".
*/
EXTERN_API( OSErr )
FSRenameUnicode (const FSRef * ref,
UniCharCount nameLength,
const UniChar * name,
TextEncoding textEncodingHint,
FSRef * newRef) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0A20, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBRenameUnicodeSync(__A0)
#endif
EXTERN_API( OSErr )
PBRenameUnicodeSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7074, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBRenameUnicodeAsync(__A0)
#endif
EXTERN_API( void )
PBRenameUnicodeAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7074, 0xA660);
/*
GetCatalogInfo
Returns various information about a given file or directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory whose information is to be returned
-> whichInfo Which catalog info fields to get
<- catInfo The returned values of catalog info fields; may be NULL
<- spec A pointer to the FSSpec for the object; may be NULL
<- parentRef A pointer to the FSRef for the object's parent directory; may be NULL
<- outName The Unicode name is returned here. This pointer may be NULL.
Note: All of the outputs are optional; if you don't want that particular output, just
set its pointer to NULL. This is the call to use to map from an FSRef to an FSSpec.
*/
EXTERN_API( OSErr )
FSGetCatalogInfo (const FSRef * ref,
FSCatalogInfoBitmap whichInfo,
FSCatalogInfo * catalogInfo, /* can be NULL */
HFSUniStr255 * outName, /* can be NULL */
FSSpec * fsSpec, /* can be NULL */
FSRef * parentRef) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0C22, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetCatalogInfoSync(__A0)
#endif
EXTERN_API( OSErr )
PBGetCatalogInfoSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7076, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBGetCatalogInfoAsync(__A0)
#endif
EXTERN_API( void )
PBGetCatalogInfoAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7076, 0xA660);
/*
SetCatalogInfo
Set catalog information about a given file or directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory whose information is to be changed
-> whichInfo Which catalog info fields to set
-> catInfo The new values of catalog info fields
Note: Only some of the catalog info fields may be set. The settable fields
are given by the constant kFSCatInfoSettableInfo; no other bits may be set in
whichInfo.
*/
EXTERN_API( OSErr )
FSSetCatalogInfo (const FSRef * ref,
FSCatalogInfoBitmap whichInfo,
const FSCatalogInfo * catalogInfo) THREEWORDINLINE(0x303C, 0x0623, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBSetCatalogInfoSync(__A0)
#endif
EXTERN_API( OSErr )
PBSetCatalogInfoSync (FSRefParam * paramBlock) TWOWORDINLINE(0x7077, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBSetCatalogInfoAsync(__A0)
#endif
EXTERN_API( void )
PBSetCatalogInfoAsync (FSRefParam * paramBlock) TWOWORDINLINE(0x7077, 0xA660);
/*
OpenIterator
Creates an FSIterator to iterate over a directory or subtree. The
iterator can then be passed to GetCatalogInfoBulk or CatalogSearch.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
<- iterator The returned FSIterator
-> iteratorFlags Controls whether the iterator iterates over subtrees
or just the immediate children of the container.
-> container An FSRef for the directory to iterate (or root of
the subtree to iterate).
*/
EXTERN_API( OSErr )
FSOpenIterator (const FSRef * container,
FSIteratorFlags iteratorFlags,
FSIterator * iterator) THREEWORDINLINE(0x303C, 0x0624, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBOpenIteratorSync(__A0)
#endif
EXTERN_API( OSErr )
PBOpenIteratorSync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x7078, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBOpenIteratorAsync(__A0)
#endif
EXTERN_API( void )
PBOpenIteratorAsync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x7078, 0xA660);
/*
CloseIterator
Invalidates and disposes an FSIterator.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> iterator The returned FSIterator
*/
EXTERN_API( OSErr )
FSCloseIterator (FSIterator iterator) THREEWORDINLINE(0x303C, 0x0225, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCloseIteratorSync(__A0)
#endif
EXTERN_API( OSErr )
PBCloseIteratorSync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x705B, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCloseIteratorAsync(__A0)
#endif
EXTERN_API( void )
PBCloseIteratorAsync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x705B, 0xA660);
/*
GetCatalogInfoBulk
Iterates over catalog objects and returns information about them.
For now, iterator must have been created with kFSIterateFlat option.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> iterator The iterator
-> maximumItems The maximum number of items to return
<- actualItems The actual number of items returned
<- containerChanged Set to true if the container's contents changed
-> whichInfo The catalog information fields to return for each item
<- catalogInfo An array of catalog information; one for each returned item
<- refs An array of FSRefs; one for each returned item
<- specs An array of FSSpecs; one for each returned item
<- names An array of filenames; one for each returned item
Note: The catalogInfo, refs, specs, names, and containerChanged are all optional outputs;
if you don't want that particular output, set its pointer to NULL.
*/
EXTERN_API( OSErr )
FSGetCatalogInfoBulk (FSIterator iterator,
ItemCount maximumObjects,
ItemCount * actualObjects,
Boolean * containerChanged, /* can be NULL */
FSCatalogInfoBitmap whichInfo,
FSCatalogInfo * catalogInfos, /* can be NULL */
FSRef * refs, /* can be NULL */
FSSpec * specs, /* can be NULL */
HFSUniStr255 * names) /* can be NULL */ THREEWORDINLINE(0x303C, 0x1226, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetCatalogInfoBulkSync(__A0)
#endif
EXTERN_API( OSErr )
PBGetCatalogInfoBulkSync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x705C, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBGetCatalogInfoBulkAsync(__A0)
#endif
EXTERN_API( void )
PBGetCatalogInfoBulkAsync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x705C, 0xA660);
/*
CatalogSearch
Iterates over catalog objects, searching for objects that match given
search criteria. Returns various information about matching objects.
For now, iterator must have been created with kFSIterateSubtree option
and the container must have been the root directory of a volume.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> iterator The iterator
-> maximumItems The maximum number of items to return
<- actualItems The actual number of items returned
<- containerChanged Set to true if the container's contents changed
-> whichInfo The catalog information fields to return for each item
<- catalogInfo An array of catalog information; one for each returned item
<- refs An array of FSRefs; one for each returned item
<- specs An array of FSSpecs; one for each returned item
<- names An array of filenames; one for each returned item
-> searchParams The criteria that controls the matching, including timeout, a bitmap
controlling the fields to compare, and the (Unicode) name to compare.
Note: The catalogInfo, refs, specs, and names are all optional outputs; if you don't want
that particular output, set its pointer to NULL.
*/
EXTERN_API( OSErr )
FSCatalogSearch (FSIterator iterator,
const FSSearchParams * searchCriteria,
ItemCount maximumObjects,
ItemCount * actualObjects,
Boolean * containerChanged, /* can be NULL */
FSCatalogInfoBitmap whichInfo,
FSCatalogInfo * catalogInfos, /* can be NULL */
FSRef * refs, /* can be NULL */
FSSpec * specs, /* can be NULL */
HFSUniStr255 * names) /* can be NULL */ THREEWORDINLINE(0x303C, 0x1427, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCatalogSearchSync(__A0)
#endif
EXTERN_API( OSErr )
PBCatalogSearchSync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x705D, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCatalogSearchAsync(__A0)
#endif
EXTERN_API( void )
PBCatalogSearchAsync (FSCatalogBulkParam * paramBlock) TWOWORDINLINE(0x705D, 0xA660);
/*
CreateFork
Create a named fork for a file or directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory
-> forkNameLength The length of the fork name (in Unicode characters)
-> forkName The name of the fork to open (in Unicode)
*/
EXTERN_API( OSErr )
FSCreateFork (const FSRef * ref,
UniCharCount forkNameLength,
const UniChar * forkName) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0636, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCreateForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBCreateForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x707D, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCreateForkAsync(__A0)
#endif
EXTERN_API( void )
PBCreateForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x707D, 0xA660);
/*
DeleteFork
Delete a named fork of a file or directory.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory
-> forkNameLength The length of the fork name (in Unicode characters)
-> forkName The name of the fork to open (in Unicode)
*/
EXTERN_API( OSErr )
FSDeleteFork (const FSRef * ref,
UniCharCount forkNameLength,
const UniChar * forkName) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0637, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBDeleteForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBDeleteForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x707E, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBDeleteForkAsync(__A0)
#endif
EXTERN_API( void )
PBDeleteForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x707E, 0xA660);
/*
IterateForks
Return the names and sizes of the forks of a file or directory.
One fork is returned per call.
-> ioCompletion A pointer to a completion routine.
<- ioResult The result code of the function.
-> ref The file or directory containing the forks.
<- positionOffset The length of the fork, in bytes.
<- allocationAmount The space allocated to the fork (physical length).
<- outForkName The name of the fork in Unicode.
<> forkIterator Maintains state between calls for a given FSRef.
Before the first call, set the initialize field to zero.
*/
EXTERN_API( OSErr )
FSIterateForks (const FSRef * ref,
CatPositionRec * forkIterator,
HFSUniStr255 * forkName, /* can be NULL */
SInt64 * forkSize, /* can be NULL */
UInt64 * forkPhysicalSize) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0A38, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBIterateForksSync(__A0)
#endif
EXTERN_API( OSErr )
PBIterateForksSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x707F, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBIterateForksAsync(__A0)
#endif
EXTERN_API( void )
PBIterateForksAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x707F, 0xA660);
/*
OpenFork
Open a fork for reading and/or writing. Allows the opened fork
to grow beyond 2GB in size. All volumes should support data and
resource forks. Other named forks may be supported by some
volumes.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ref The file or directory containing the fork to open
-> forkNameLength The length of the fork name (in Unicode characters)
-> forkName The name of the fork to open (in Unicode)
-> permissions The access (read and/or write) you want
<- forkRefNum The reference number for accessing the open fork
*/
EXTERN_API( OSErr )
FSOpenFork (const FSRef * ref,
UniCharCount forkNameLength,
const UniChar * forkName, /* can be NULL */
SInt8 permissions,
SInt16 * forkRefNum) THREEWORDINLINE(0x303C, 0x0928, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBOpenForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBOpenForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7079, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBOpenForkAsync(__A0)
#endif
EXTERN_API( void )
PBOpenForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7079, 0xA660);
/*
ReadFork
Read data from a fork opened via OpenFork. The first byte to read is
indicated by a combination of positionMode and positionOffset.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork to read from
<- buffer Pointer to buffer where data will be returned
-> requestCount The number of bytes to read
<- actualCount The number of bytes actually read
-> positionMode The base location for start of read
-> positionOffset The offset from base location for start of read
*/
EXTERN_API( OSErr )
FSReadFork (SInt16 forkRefNum,
UInt16 positionMode,
SInt64 positionOffset,
ByteCount requestCount,
void * buffer,
ByteCount * actualCount) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0A29, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBReadForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBReadForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7051, 0xA2A8);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBReadForkAsync(__A0)
#endif
EXTERN_API( void )
PBReadForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7051, 0xA6A8);
/*
WriteFork
Write data to a fork opened via OpenFork. The first byte to write is
indicated by a combination of positionMode and positionOffset.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork to write to
-> buffer Pointer to data to write
-> requestCount The number of bytes to write
<- actualCount The number of bytes actually written
-> positionMode The base location for start of write
-> positionOffset The offset from base location for start of write
*/
EXTERN_API( OSErr )
FSWriteFork (SInt16 forkRefNum,
UInt16 positionMode,
SInt64 positionOffset,
ByteCount requestCount,
void * buffer,
ByteCount * actualCount) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0A2A, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBWriteForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBWriteForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7052, 0xA2A8);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBWriteForkAsync(__A0)
#endif
EXTERN_API( void )
PBWriteForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7052, 0xA6A8);
/*
GetForkPosition
Get the current (default) position of a fork that was
opened via OpenFork.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork
<- positionOffset The current position of the fork
*/
EXTERN_API( OSErr )
FSGetForkPosition (SInt16 forkRefNum,
SInt64 * position) THREEWORDINLINE(0x303C, 0x032B, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetForkPositionSync(__A0)
#endif
EXTERN_API( OSErr )
PBGetForkPositionSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7053, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBGetForkPositionAsync(__A0)
#endif
EXTERN_API( void )
PBGetForkPositionAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7053, 0xA660);
/*
SetForkPosition
Set the current (default) position of a fork that was
opened via OpenFork.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork
-> positionMode The base location for the new position
-> positionOffset The offset of the new position from the base
*/
EXTERN_API( OSErr )
FSSetForkPosition (SInt16 forkRefNum,
UInt16 positionMode,
SInt64 positionOffset) THREEWORDINLINE(0x303C, 0x042C, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBSetForkPositionSync(__A0)
#endif
EXTERN_API( OSErr )
PBSetForkPositionSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7054, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBSetForkPositionAsync(__A0)
#endif
EXTERN_API( void )
PBSetForkPositionAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7054, 0xA660);
/*
GetForkSize
Get the current logical size (end-of-file) of an open fork.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork
<- positionOffset The logical size of the fork, in bytes
*/
EXTERN_API( OSErr )
FSGetForkSize (SInt16 forkRefNum,
SInt64 * forkSize) THREEWORDINLINE(0x303C, 0x032D, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetForkSizeSync(__A0)
#endif
EXTERN_API( OSErr )
PBGetForkSizeSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7055, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBGetForkSizeAsync(__A0)
#endif
EXTERN_API( void )
PBGetForkSizeAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7055, 0xA660);
/*
SetForkSize
Set the logical size (end-of-file) of an open fork. This
may cause space to be allocated or deallocated.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork
-> positionMode The base location for the new size
-> positionOffset The offset of the new size from the base
*/
EXTERN_API( OSErr )
FSSetForkSize (SInt16 forkRefNum,
UInt16 positionMode,
SInt64 positionOffset) THREEWORDINLINE(0x303C, 0x042E, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBSetForkSizeSync(__A0)
#endif
EXTERN_API( OSErr )
PBSetForkSizeSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7056, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBSetForkSizeAsync(__A0)
#endif
EXTERN_API( void )
PBSetForkSizeAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7056, 0xA660);
/*
AllocateFork
Allocate space to an open fork. Typically, the space to be
allocated is beyond the current size of the fork, to reserve
space so the file will be able to grow later. Some volume
formats are unable to allocate space beyond the logical size
of the fork.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork
-> positionMode The base location for start of allocation
-> positionOffset The offset of the start of allocation
-> allocationFlags Zero or more of the following flags:
kFSAllocContiguousMask
Any newly allocated space must be one contiguous piece.
kFSAllocAllOrNothingMask
All of the request space must be available, or the call
will fail. (If not set, the call may succeed even though
some of the requested space wasn't allocated.)
kFSAllocNoRoundUpMask
Do not allocate additional space. (If not set, a volume
may allocate additional space in order to reduce fragmentation.)
<> allocationAmount The number of bytes to allocate
On output, the number of bytes actually added
*/
EXTERN_API( OSErr )
FSAllocateFork (SInt16 forkRefNum,
FSAllocationFlags flags,
UInt16 positionMode,
SInt64 positionOffset,
UInt64 requestCount,
UInt64 * actualCount) /* can be NULL */ THREEWORDINLINE(0x303C, 0x092F, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBAllocateForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBAllocateForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7057, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBAllocateForkAsync(__A0)
#endif
EXTERN_API( void )
PBAllocateForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7057, 0xA660);
/*
FlushFork
Flush a fork. Any data written to this fork refnum is flushed to the device.
The volume's control structures are also flushed to the device.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork to flush
*/
EXTERN_API( OSErr )
FSFlushFork (SInt16 forkRefNum) THREEWORDINLINE(0x303C, 0x0130, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBFlushForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBFlushForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7058, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBFlushForkAsync(__A0)
#endif
EXTERN_API( void )
PBFlushForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7058, 0xA660);
/*
CloseFork
Flush and close a fork. Any data written to this fork refnum is flushed
to the device. The volume's control structures are also flushed to the device.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> forkRefNum The reference number of the fork to close
*/
EXTERN_API( OSErr )
FSCloseFork (SInt16 forkRefNum) THREEWORDINLINE(0x303C, 0x0131, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCloseForkSync(__A0)
#endif
EXTERN_API( OSErr )
PBCloseForkSync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7059, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBCloseForkAsync(__A0)
#endif
EXTERN_API( void )
PBCloseForkAsync (FSForkIOParam * paramBlock) TWOWORDINLINE(0x7059, 0xA660);
/*
GetForkCBInfo
Return information about an open fork.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
<> desiredRefNum If non-zero on input, then get information for this refnum;
unchanged on output. If zero on input, iterate over all open
forks (possibly limited to a single volume); on output, contains
the fork's refnum.
-> volumeRefNum Used when desiredRefNum is zero on input. Set to 0 to iterate over all
volumes, or set to a FSVolumeRefNum to limit iteration to that volume.
<> iterator Used when desiredRefNum is zero on input. Set to 0 before iterating.
Pass the iterator returned by the previous call to continue iterating.
<- actualRefNum The refnum of the open fork.
<- ref The FSRef for the file or directory that contains the fork.
<- forkInfo Various information about the open fork.
<- outForkName The name of the fork
Note: the foundRefNum, ref, forkInfo, and fork name outputs are all optional; if you don't want
a particular output, then set its pointer to NULL. If forkName is NULL, then forkNameLength
will be undefined.
Note: Returning the forkInfo generally does not require a disk access. Returning the
ref or forkName may cause disk access for some volume formats.
*/
EXTERN_API( OSErr )
FSGetForkCBInfo (SInt16 desiredRefNum,
FSVolumeRefNum volume,
SInt16 * iterator, /* can be NULL */
SInt16 * actualRefNum, /* can be NULL */
FSForkInfo * forkInfo, /* can be NULL */
FSRef * ref, /* can be NULL */
HFSUniStr255 * outForkName) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0C32, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetForkCBInfoSync(__A0)
#endif
EXTERN_API( OSErr )
PBGetForkCBInfoSync (FSForkCBInfoParam * paramBlock) TWOWORDINLINE(0x705A, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBGetForkCBInfoAsync(__A0)
#endif
EXTERN_API( void )
PBGetForkCBInfoAsync (FSForkCBInfoParam * paramBlock) TWOWORDINLINE(0x705A, 0xA660);
/*
GetVolumeInfo
Returns various information about a given volume, or indexing over all volumes.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
<> ioVRefNum On input, the volume reference number or drive number whose
information is to be returned (if volumeIndex is 0); same
as "volume" input to FSGetVolumeInfo.
On output, the actual volume reference number; same as
"actualVolume" output of FSGetVolumeInfo.
-> volumeIndex The index of the desired volume, or 0 to use ioVRefNum
-> whichInfo Which volInfo info fields to get
<- volumeInfo The returned values of Volume info fields; may be NULL
<- name The Unicode name is returned here. This pointer may be NULL.
Note: All of the outputs are optional; if you don't want that particular output, just
set it's pointer to NULL.
*/
EXTERN_API( OSErr )
FSGetVolumeInfo (FSVolumeRefNum volume,
ItemCount volumeIndex,
FSVolumeRefNum * actualVolume, /* can be NULL */
FSVolumeInfoBitmap whichInfo,
FSVolumeInfo * info, /* can be NULL */
HFSUniStr255 * volumeName, /* can be NULL */
FSRef * rootDirectory) /* can be NULL */ THREEWORDINLINE(0x303C, 0x0D33, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBGetVolumeInfoSync(__A0)
#endif
EXTERN_API( OSErr )
PBGetVolumeInfoSync (FSVolumeInfoParam * paramBlock) TWOWORDINLINE(0x701D, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBGetVolumeInfoAsync(__A0)
#endif
EXTERN_API( void )
PBGetVolumeInfoAsync (FSVolumeInfoParam * paramBlock) TWOWORDINLINE(0x701D, 0xA660);
/*
SetVolumeInfo
Set information about a given volume.
-> ioCompletion A pointer to a completion routine
<- ioResult The result code of the function
-> ioVRefNum The volume whose information is to be changed
-> whichInfo Which catalog info fields to set
-> volumeInfo The new values of volume info fields
Note: Only some of the volume info fields may be set. The settable fields
are given by the constant kFSVolInfoSettableInfo; no other bits may be set in
whichInfo.
*/
EXTERN_API( OSErr )
FSSetVolumeInfo (FSVolumeRefNum volume,
FSVolumeInfoBitmap whichInfo,
const FSVolumeInfo * info) THREEWORDINLINE(0x303C, 0x0534, 0xAA52);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBSetVolumeInfoSync(__A0)
#endif
EXTERN_API( OSErr )
PBSetVolumeInfoSync (FSVolumeInfoParam * paramBlock) TWOWORDINLINE(0x701E, 0xA260);
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter PBSetVolumeInfoAsync(__A0)
#endif
EXTERN_API( void )
PBSetVolumeInfoAsync (FSVolumeInfoParam * paramBlock) TWOWORDINLINE(0x701E, 0xA660);
/*
FSGetDataForkName
Returns the constant for the name of the data fork (the empty string)
*/
EXTERN_API( OSErr )
FSGetDataForkName (HFSUniStr255 * dataForkName) THREEWORDINLINE(0x303C, 0x0218, 0xAA52);
/*
FSGetResourceForkName
Returns the constant for the name of the resource fork
(currently "RESOURCE_FORK").
*/
EXTERN_API( OSErr )
FSGetResourceForkName (HFSUniStr255 * resourceForkName) THREEWORDINLINE(0x303C, 0x0219, 0xAA52);
#if PRAGMA_STRUCT_ALIGN
#pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
#ifdef __cplusplus
}
#endif
#endif /* __FILES__ */