1 {
2 File: CarbonCore/Files.h
3
4 Contains: File Manager Interfaces.
5 The contents of this header file are deprecated.
6 Use Foundation, CoreFoundation, DiskArbitration, POSIX/BSD, etc. API instead.
7
8 Copyright: � 1985-2011 Apple, Inc. All rights reserved
9 }
10 { Pascal Translation Updated: Gale R Paeper, <gpaeper@empirenet.com>, June 2018 }
11
12 {
13 Modified for use with Free Pascal
14 Version 308
15 Please report any bugs to <gpc@microbizz.nl>
16 }
17
18 {$ifc not defined MACOSALLINCLUDE or not MACOSALLINCLUDE}
19 {$mode macpas}
20 {$modeswitch cblocks}
21 {$packenum 1}
22 {$macro on}
23 {$inline on}
24 {$calling mwpascal}
25
26 unit Files;
27 interface
28 {$setc UNIVERSAL_INTERFACES_VERSION := $0400}
29 {$setc GAP_INTERFACES_VERSION := $0308}
30
31 {$ifc not defined USE_CFSTR_CONSTANT_MACROS}
32 {$setc USE_CFSTR_CONSTANT_MACROS := TRUE}
33 {$endc}
34
35 {$ifc defined CPUPOWERPC and defined CPUI386}
36 {$error Conflicting initial definitions for CPUPOWERPC and CPUI386}
37 {$endc}
38 {$ifc defined FPC_BIG_ENDIAN and defined FPC_LITTLE_ENDIAN}
39 {$error Conflicting initial definitions for FPC_BIG_ENDIAN and FPC_LITTLE_ENDIAN}
40 {$endc}
41
42 {$ifc not defined __ppc__ and defined CPUPOWERPC32}
43 {$setc __ppc__ := 1}
44 {$elsec}
45 {$setc __ppc__ := 0}
46 {$endc}
47 {$ifc not defined __ppc64__ and defined CPUPOWERPC64}
48 {$setc __ppc64__ := 1}
49 {$elsec}
50 {$setc __ppc64__ := 0}
51 {$endc}
52 {$ifc not defined __i386__ and defined CPUI386}
53 {$setc __i386__ := 1}
54 {$elsec}
55 {$setc __i386__ := 0}
56 {$endc}
57 {$ifc not defined __x86_64__ and defined CPUX86_64}
58 {$setc __x86_64__ := 1}
59 {$elsec}
60 {$setc __x86_64__ := 0}
61 {$endc}
62 {$ifc not defined __arm__ and defined CPUARM}
63 {$setc __arm__ := 1}
64 {$elsec}
65 {$setc __arm__ := 0}
66 {$endc}
67 {$ifc not defined __arm64__ and defined CPUAARCH64}
68 {$setc __arm64__ := 1}
69 {$elsec}
70 {$setc __arm64__ := 0}
71 {$endc}
72
73 {$ifc defined cpu64}
74 {$setc __LP64__ := 1}
75 {$elsec}
76 {$setc __LP64__ := 0}
77 {$endc}
78
79
80 {$ifc defined __ppc__ and __ppc__ and defined __i386__ and __i386__}
81 {$error Conflicting definitions for __ppc__ and __i386__}
82 {$endc}
83
84 {$ifc defined __ppc__ and __ppc__}
85 {$setc TARGET_CPU_PPC := TRUE}
86 {$setc TARGET_CPU_PPC64 := FALSE}
87 {$setc TARGET_CPU_X86 := FALSE}
88 {$setc TARGET_CPU_X86_64 := FALSE}
89 {$setc TARGET_CPU_ARM := FALSE}
90 {$setc TARGET_CPU_ARM64 := FALSE}
91 {$setc TARGET_OS_MAC := TRUE}
92 {$setc TARGET_OS_IPHONE := FALSE}
93 {$setc TARGET_IPHONE_SIMULATOR := FALSE}
94 {$setc TARGET_OS_EMBEDDED := FALSE}
95 {$elifc defined __ppc64__ and __ppc64__}
96 {$setc TARGET_CPU_PPC := FALSE}
97 {$setc TARGET_CPU_PPC64 := TRUE}
98 {$setc TARGET_CPU_X86 := FALSE}
99 {$setc TARGET_CPU_X86_64 := FALSE}
100 {$setc TARGET_CPU_ARM := FALSE}
101 {$setc TARGET_CPU_ARM64 := FALSE}
102 {$setc TARGET_OS_MAC := TRUE}
103 {$setc TARGET_OS_IPHONE := FALSE}
104 {$setc TARGET_IPHONE_SIMULATOR := FALSE}
105 {$setc TARGET_OS_EMBEDDED := FALSE}
106 {$elifc defined __i386__ and __i386__}
107 {$setc TARGET_CPU_PPC := FALSE}
108 {$setc TARGET_CPU_PPC64 := FALSE}
109 {$setc TARGET_CPU_X86 := TRUE}
110 {$setc TARGET_CPU_X86_64 := FALSE}
111 {$setc TARGET_CPU_ARM := FALSE}
112 {$setc TARGET_CPU_ARM64 := FALSE}
113 {$ifc defined iphonesim}
114 {$setc TARGET_OS_MAC := FALSE}
115 {$setc TARGET_OS_IPHONE := TRUE}
116 {$setc TARGET_IPHONE_SIMULATOR := TRUE}
117 {$elsec}
118 {$setc TARGET_OS_MAC := TRUE}
119 {$setc TARGET_OS_IPHONE := FALSE}
120 {$setc TARGET_IPHONE_SIMULATOR := FALSE}
121 {$endc}
122 {$setc TARGET_OS_EMBEDDED := FALSE}
123 {$elifc defined __x86_64__ and __x86_64__}
124 {$setc TARGET_CPU_PPC := FALSE}
125 {$setc TARGET_CPU_PPC64 := FALSE}
126 {$setc TARGET_CPU_X86 := FALSE}
127 {$setc TARGET_CPU_X86_64 := TRUE}
128 {$setc TARGET_CPU_ARM := FALSE}
129 {$setc TARGET_CPU_ARM64 := FALSE}
130 {$ifc defined iphonesim}
131 {$setc TARGET_OS_MAC := FALSE}
132 {$setc TARGET_OS_IPHONE := TRUE}
133 {$setc TARGET_IPHONE_SIMULATOR := TRUE}
134 {$elsec}
135 {$setc TARGET_OS_MAC := TRUE}
136 {$setc TARGET_OS_IPHONE := FALSE}
137 {$setc TARGET_IPHONE_SIMULATOR := FALSE}
138 {$endc}
139 {$setc TARGET_OS_EMBEDDED := FALSE}
140 {$elifc defined __arm__ and __arm__}
141 {$setc TARGET_CPU_PPC := FALSE}
142 {$setc TARGET_CPU_PPC64 := FALSE}
143 {$setc TARGET_CPU_X86 := FALSE}
144 {$setc TARGET_CPU_X86_64 := FALSE}
145 {$setc TARGET_CPU_ARM := TRUE}
146 {$setc TARGET_CPU_ARM64 := FALSE}
147 {$setc TARGET_OS_MAC := FALSE}
148 {$setc TARGET_OS_IPHONE := TRUE}
149 {$setc TARGET_IPHONE_SIMULATOR := FALSE}
150 {$setc TARGET_OS_EMBEDDED := TRUE}
151 {$elifc defined __arm64__ and __arm64__}
152 {$setc TARGET_CPU_PPC := FALSE}
153 {$setc TARGET_CPU_PPC64 := FALSE}
154 {$setc TARGET_CPU_X86 := FALSE}
155 {$setc TARGET_CPU_X86_64 := FALSE}
156 {$setc TARGET_CPU_ARM := FALSE}
157 {$setc TARGET_CPU_ARM64 := TRUE}
158 {$ifc defined ios}
159 {$setc TARGET_OS_MAC := FALSE}
160 {$setc TARGET_OS_IPHONE := TRUE}
161 {$setc TARGET_OS_EMBEDDED := TRUE}
162 {$elsec}
163 {$setc TARGET_OS_MAC := TRUE}
164 {$setc TARGET_OS_IPHONE := FALSE}
165 {$setc TARGET_OS_EMBEDDED := FALSE}
166 {$endc}
167 {$setc TARGET_IPHONE_SIMULATOR := FALSE}
168 {$elsec}
169 {$error __ppc__ nor __ppc64__ nor __i386__ nor __x86_64__ nor __arm__ nor __arm64__ is defined.}
170 {$endc}
171
172 {$ifc defined __LP64__ and __LP64__ }
173 {$setc TARGET_CPU_64 := TRUE}
174 {$elsec}
175 {$setc TARGET_CPU_64 := FALSE}
176 {$endc}
177
178 {$ifc defined FPC_BIG_ENDIAN}
179 {$setc TARGET_RT_BIG_ENDIAN := TRUE}
180 {$setc TARGET_RT_LITTLE_ENDIAN := FALSE}
181 {$elifc defined FPC_LITTLE_ENDIAN}
182 {$setc TARGET_RT_BIG_ENDIAN := FALSE}
183 {$setc TARGET_RT_LITTLE_ENDIAN := TRUE}
184 {$elsec}
185 {$error Neither FPC_BIG_ENDIAN nor FPC_LITTLE_ENDIAN are defined.}
186 {$endc}
187 {$setc ACCESSOR_CALLS_ARE_FUNCTIONS := TRUE}
188 {$setc CALL_NOT_IN_CARBON := FALSE}
189 {$setc OLDROUTINENAMES := FALSE}
190 {$setc OPAQUE_TOOLBOX_STRUCTS := TRUE}
191 {$setc OPAQUE_UPP_TYPES := TRUE}
192 {$setc OTCARBONAPPLICATION := TRUE}
193 {$setc OTKERNEL := FALSE}
194 {$setc PM_USE_SESSION_APIS := TRUE}
195 {$setc TARGET_API_MAC_CARBON := TRUE}
196 {$setc TARGET_API_MAC_OS8 := FALSE}
197 {$setc TARGET_API_MAC_OSX := TRUE}
198 {$setc TARGET_CARBON := TRUE}
199 {$setc TARGET_CPU_68K := FALSE}
200 {$setc TARGET_CPU_MIPS := FALSE}
201 {$setc TARGET_CPU_SPARC := FALSE}
202 {$setc TARGET_OS_UNIX := FALSE}
203 {$setc TARGET_OS_WIN32 := FALSE}
204 {$setc TARGET_RT_MAC_68881 := FALSE}
205 {$setc TARGET_RT_MAC_CFM := FALSE}
206 {$setc TARGET_RT_MAC_MACHO := TRUE}
207 {$setc TYPED_FUNCTION_POINTERS := TRUE}
208 {$setc TYPE_BOOL := FALSE}
209 {$setc TYPE_EXTENDED := FALSE}
210 {$setc TYPE_LONGLONG := TRUE}
211 uses acl,MacTypes,MixedMode,OSUtils,TextCommon,UTCUtils,Finder,MacOSXPosix,DADisk,CFBase,CFDate,CFDictionary,CFRunLoop,CFUUID;
212 {$endc} {not MACOSALLINCLUDE}
213
214
215 {$ifc TARGET_OS_MAC}
216
217 { Finder constants were moved to Finder.� }
218
219
220 {$ALIGN MAC68K}
221
222 { HFSUniStr255 is the Unicode equivalent of Str255 }
223 type
224 HFSUniStr255Ptr = ^HFSUniStr255;
225 HFSUniStr255 = record
226 length: UInt16; { number of unicode characters }
227 unicode: array [0..254] of UniChar; { unicode characters }
228 end;
229 type
230 ConstHFSUniStr255Param = ^HFSUniStr255;
231
232 type
233 DirIDTypePtr = ^DirIDType;
234 DirIDType = SInt32;
235
236 const kFSFileSecurityRemoveACL = acl_t(1);
237
238 {
239 File Permissions
240
241 Do not mix and match the following two sets of File Manager permission
242 constants (original model and AFP model).
243 See the Retired Technote FL 37 "You Want Permission To Do What?!!"
244 <https://developer.apple.com/legacy/mac/library/#technotes/fl/fl_37.html#//apple_ref/doc/uid/DTS10002463>
245 for a detailed discussion of the two separate models
246 and how they are related.
247 }
248 { Permissions for File Manager routines which follow the original model.
249 These values can be passed in the permissions parameter to FSOpenFork,
250 PBOpenForkSync, and PBOpenForkAsync.
251 }
252 const
253 fsCurPerm = $00; { open access permissions in ioPermssn }
254 fsRdPerm = $01;
255 fsWrPerm = $02;
256 fsRdWrPerm = $03;
257 fsRdWrShPerm = $04;
258
259 { Permissions for deprecated File Manager routines which follow the AFP model
260 that is, routines with "OpenDeny" in the name. (These values do not work with
261 FSOpenFork, PBOpenForkSync, and PBOpenForkAsync).
262
263 The most useful combinations of these are:
264 fsRdAccessPerm -> one writer, multiple readers: the readers
265 fsRdAccessPerm + fsWrAccessPerm + fsWrDenyPerm -> one writer, multiple readers: the writer
266 fsWrDenyPerm + fsRdAccessPerm -> multiple readers, no writers
267 fsRdAccessPerm + fsWrAccessPerm -> shared read/write access
268 fsRdAccessPerm + fsWrAccessPerm + fsRdDenyPerm + fsWrDenyPerm -> exclusive access
269 }
270 const
271 fsRdAccessPerm = $01;
272 fsWrAccessPerm = $02;
273 fsRdDenyPerm = $10;
274 fsWrDenyPerm = $20;
275
276 const
277 fsRtParID = 1;
278 fsRtDirID = 2;
279
280 const
281 fsAtMark = 0; { positioning modes in ioPosMode }
282 fsFromStart = 1;
283 fsFromLEOF = 2;
284 fsFromMark = 3;
285
286 const
287 { positionMode (ioPosMode) flags }
288 kFSAllowConcurrentAsyncIOBit = 3; { allow concurrent execution of async calls }
289 kFSAllowConcurrentAsyncIOMask = $0008;
290 kFSPleaseCacheBit = 4; { please cache this request }
291 kFSPleaseCacheMask = $0010;
292 kFSNoCacheBit = 5; { please don't cache this request }
293 kFSNoCacheMask = $0020;
294 kFSRdVerifyBit = 6; { read verify mode }
295 kFSRdVerifyMask = $0040;
296 kFSForceReadBit = 6;
297 kFSForceReadMask = $0040;
298 kFSNewLineBit = 7; { newline mode }
299 kFSNewLineMask = $0080;
300 kFSNewLineCharMask = $FF00; { newline character }
301
302
303 const
304 { CatSearch Search bitmask Constants }
305 fsSBPartialName = $01;
306 fsSBFullName = $02;
307 fsSBFlAttrib = $04;
308 fsSBFlFndrInfo = $08;
309 fsSBFlLgLen = $20;
310 fsSBFlPyLen = $40;
311 fsSBFlRLgLen = $80;
312 fsSBFlRPyLen = $0100;
313 fsSBFlCrDat = $0200;
314 fsSBFlMdDat = $0400;
315 fsSBFlBkDat = $0800;
316 fsSBFlXFndrInfo = $1000;
317 fsSBFlParID = $2000;
318 fsSBNegate = $4000;
319 fsSBDrUsrWds = $08;
320 fsSBDrNmFls = $10;
321 fsSBDrCrDat = $0200;
322 fsSBDrMdDat = $0400;
323 fsSBDrBkDat = $0800;
324 fsSBDrFndrInfo = $1000;
325 fsSBDrParID = $2000;
326 fsSBNodeID = $8000;
327 fsSBAttributeModDate = $00010000;
328 fsSBAccessDate = $00020000;
329 fsSBPermissions = $00040000;
330 fsSBSkipPackageContents = $00080000;
331 fsSBSkipHiddenItems = $00100000;
332 fsSBUserID = $00200000;
333 fsSBGroupID = $00400000;
334
335 const
336 { CatSearch Search bit value Constants }
337 fsSBPartialNameBit = 0; {ioFileName points to a substring}
338 fsSBFullNameBit = 1; {ioFileName points to a match string}
339 fsSBFlAttribBit = 2; {search includes file attributes}
340 fsSBFlFndrInfoBit = 3; {search includes finder info}
341 fsSBFlLgLenBit = 5; {search includes data logical length}
342 fsSBFlPyLenBit = 6; {search includes data physical length}
343 fsSBFlRLgLenBit = 7; {search includes resource logical length}
344 fsSBFlRPyLenBit = 8; {search includes resource physical length}
345 fsSBFlCrDatBit = 9; {search includes create date}
346 fsSBFlMdDatBit = 10; {search includes modification date}
347 fsSBFlBkDatBit = 11; {search includes backup date}
348 fsSBFlXFndrInfoBit = 12; {search includes extended finder info}
349 fsSBFlParIDBit = 13; {search includes file's parent ID}
350 fsSBNegateBit = 14; {return all non-matches}
351 fsSBDrUsrWdsBit = 3; {search includes directory finder info}
352 fsSBDrNmFlsBit = 4; {search includes directory valence}
353 fsSBDrCrDatBit = 9; {directory-named version of fsSBFlCrDatBit}
354 fsSBDrMdDatBit = 10; {directory-named version of fsSBFlMdDatBit}
355 fsSBDrBkDatBit = 11; {directory-named version of fsSBFlBkDatBit}
356 fsSBDrFndrInfoBit = 12; {directory-named version of fsSBFlXFndrInfoBit}
357 fsSBDrParIDBit = 13; {directory-named version of fsSBFlParIDBit}
358 fsSBNodeIDBit = 15; { search by range of nodeID }
359 fsSBAttributeModDateBit = 16; { search by range of attributeModDate }
360 fsSBAccessDateBit = 17; { search by range of accessDate [CatalogSearch only] }
361 fsSBPermissionsBit = 18; { search by value/mask of permissions [CatalogSearch only] }
362 fsSBSkipPackageContentsBit = 19; {do not return items inside of packages}
363 fsSBSkipHiddenItemsBit = 20; {do not return items with an invisible element in their path}
364 fsSBUserIDBit = 21; { search by userID in permissions field [CatalogSearch only] }
365 fsSBGroupIDBit = 22; { search by groupID in permissions field [CatalogSearch only] }
366
367 const
368 { vMAttrib (GetVolParms) bit position constants }
369 bLimitFCBs = 31;
370 bLocalWList = 30;
371 bNoMiniFndr = 29;
372 bNoVNEdit = 28;
373 bNoLclSync = 27;
374 bTrshOffLine = 26;
375 bNoSwitchTo = 25;
376 bNoDeskItems = 20;
377 bNoBootBlks = 19;
378 bAccessCntl = 18;
379 bNoSysDir = 17;
380 bHasExtFSVol = 16;
381 bHasOpenDeny = 15;
382 bHasCopyFile = 14;
383 bHasMoveRename = 13;
384 bHasDesktopMgr = 12;
385 bHasShortName = 11;
386 bHasFolderLock = 10;
387 bHasPersonalAccessPrivileges = 9;
388 bHasUserGroupList = 8;
389 bHasCatSearch = 7;
390 bHasFileIDs = 6;
391 bHasBTreeMgr = 5;
392 bHasBlankAccessPrivileges = 4;
393 bSupportsAsyncRequests = 3; { asynchronous requests to this volume are handled correctly at any time}
394 bSupportsTrashVolumeCache = 2;
395
396 const
397 { vMAttrib (GetVolParms) bit position constants }
398 bHasDirectIO = 1;
399
400 const
401 { vMExtendedAttributes (GetVolParms) bit position constants }
402 bIsEjectable = 0; { volume is in an ejectable disk drive }
403 bSupportsHFSPlusAPIs = 1; { volume supports HFS Plus APIs directly (not through compatibility layer) }
404 bSupportsFSCatalogSearch = 2; { volume supports FSCatalogSearch }
405 bSupportsFSExchangeObjects = 3; { volume supports FSExchangeObjects }
406 bSupports2TBFiles = 4; { volume supports supports 2 terabyte files }
407 bSupportsLongNames = 5; { volume supports file/directory/volume names longer than 31 characters }
408 bSupportsMultiScriptNames = 6; { volume supports file/directory/volume names with characters from multiple script systems }
409 bSupportsNamedForks = 7; { volume supports forks beyond the data and resource forks }
410 bSupportsSubtreeIterators = 8; { volume supports recursive iterators not at the volume root }
411 bL2PCanMapFileBlocks = 9; { volume supports Lg2Phys SPI correctly }
412 bParentModDateChanges = 10; { Changing a file or folder causes its parent's mod date to change }
413 bAncestorModDateChanges = 11; { Changing a file or folder causes all ancestor mod dates to change }
414 bSupportsSymbolicLinks = 13; { volume supports the creation and use of symbolic links (Mac OS X only) }
415 bIsAutoMounted = 14; { volume was mounted automatically (Mac OS X only) }
416 bAllowCDiDataHandler = 17; { allow QuickTime's CDi data handler to examine this volume }
417 bSupportsExclusiveLocks = 18; { volume supports exclusive opens for writing }
418 bSupportsJournaling = 19; { volume supports journal (journal may not be active) }
419 bNoVolumeSizes = 20; { volume is unable to report volume size or free space }
420 bIsOnInternalBus = 21; { device is on an internal bus - see note below }
421 bIsCaseSensitive = 22; { volume is case sensitive }
422 bIsCasePreserving = 23; { volume is case preserving }
423 bDoNotDisplay = 24; { volume should not be displayed in UI }
424 bIsRemovable = 25; { device is removable according to IOKit }
425 bNoRootTimes = 26; { volume does not set reliable times for its root directory }
426 bIsOnExternalBus = 27; { device is on an external bus -- see note below }
427 bSupportsExtendedFileSecurity = 28; { volume supports FSFileSecurity objects }
428
429 { Note: A volume can return one of four states via the bIsInternal and bIsExternal bits. A volume known
430 to be on an internal bus will set bIsInternal and clear bIsExternal. A volume known to
431 be on an external bus will clear bIsInternal and set bIsExternal. A volume on a bus that
432 is indeterminate (could be either) will set both bits. A volume not on a local bus will, such
433 as a network volume, will leave both bits clear. }
434 const
435 { Large Volume Constants }
436 kWidePosOffsetBit = 8;
437 kUseWidePositioning = 1 shl kWidePosOffsetBit;
438 kMaximumBlocksIn4GB = $007FFFFF;
439
440 const
441 { Foreign Privilege Model Identifiers }
442 fsUnixPriv = 1;
443
444 const
445 { Authentication Constants }
446 kNoUserAuthentication = 1;
447 kPassword = 2;
448 kEncryptPassword = 3;
449 kTwoWayEncryptPassword = 6;
450
451
452 { values of user IDs and group IDs }
453 const
454 knoUser = 0;
455 kadministratorUser = 1;
456
457 const
458 knoGroup = 0;
459
460
461 type
462 FSVolumeRefNum = SInt16;
463 FSVolumeRefNumPtr = ^FSVolumeRefNum; { when a VAR xx: FSVolumeRefNum parameter can be nil, it is changed to xx: FSVolumeRefNumPtr }
464 {$ifc TARGET_CPU_64}
465 type
466 FSIORefNum = SInt32;
467 {$elsec}
468 type
469 FSIORefNum = SInt16;
470 {$endc}
471
472 const
473 kFSInvalidVolumeRefNum = 0;
474
475 type
476 FSRef = record
477 hidden: packed array [0..79] of UInt8; { private to File Manager; �� need symbolic constant }
478 end;
479 FSRefPtr = ^FSRef;
480 type
481 FSFileSecurityRef = ^__FSFileSecurity; { an opaque type }
482 __FSFileSecurity = record end;
483 { Catalog position record }
484 type
485 CatPositionRecPtr = ^CatPositionRec;
486 CatPositionRec = record
487 initialize: SInt32;
488 priv: array [1..6] of SInt16;
489 end;
490
491 {$ifc TARGET_CPU_64}
492 type
493 FSSpec = record
494 { FSSpecs are invalid for 64 bit, but defined in case they appear in shared structs}
495 hidden: array [1..70] of UInt8;
496 end;
497 {$elsec}
498 type
499 FSSpec = record
500 vRefNum: FSVolumeRefNum;
501 parID: SInt32;
502 name: StrFileName; { a Str63 on MacOS}
503 end;
504 {$endc}
505 type
506 FSSpecPtr = ^FSSpec;
507 type
508 FSSpecHandle = ^FSSpecPtr;
509 { pointer to array of FSSpecs }
510 type
511 FSSpecArray = array [0..0] of FSSpec;
512 FSSpecArrayPtr = ^FSSpecArray;
513 {
514 The only difference between "const FSSpec*" and "ConstFSSpecPtr" is
515 that as a parameter, ConstFSSpecPtr is allowed to be NULL
516 }
517 type
518 ConstFSSpecPtr = {const} FSSpecPtr;
519
520 type
521 {$ifc TARGET_CPU_64}
522 ParmBlkPtr = UnivPtr;
523 {$elsec}
524 ParmBlkPtr = ^ParamBlockRec;
525 {$endc}
526
527 IOCompletionProcPtr = procedure( paramBlock: ParmBlkPtr );
528 IOCompletionUPP = IOCompletionProcPtr;
529
530 {$ifc not TARGET_CPU_64}
531 IOParam = record
532 qLink: QElemPtr; {queue link in header}
533 qType: SInt16; {type byte for safety check}
534 ioTrap: SInt16; {FS: the Trap}
535 ioCmdAddr: Ptr; {FS: address to dispatch to}
536 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
537 ioResult: {volatile} OSErr; {result code}
538 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
539 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
540 ioRefNum: FSIORefNum; {refNum for I/O operation}
541 ioVersNum: SInt8; {version number}
542 ioPermssn: SInt8; {Open: permissions (byte)}
543 ioMisc: Ptr; {Rename: new name (GetEOF,SetEOF: logical end of file) (Open: optional ptr to buffer) (SetFileType: new type)}
544 ioBuffer: Ptr; {data buffer Ptr}
545 ioReqCount: SInt32; {requested byte count; also = ioNewDirID}
546 ioActCount: SInt32; {actual byte count completed}
547 ioPosMode: SInt16; {initial file positioning}
548 ioPosOffset: SInt32; {file position offset}
549 end;
550 IOParamPtr = ^IOParam;
551
552 FileParam = record
553 qLink: QElemPtr; {queue link in header}
554 qType: SInt16; {type byte for safety check}
555 ioTrap: SInt16; {FS: the Trap}
556 ioCmdAddr: Ptr; {FS: address to dispatch to}
557 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
558 ioResult: {volatile} OSErr; {result code}
559 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
560 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
561 ioFRefNum: FSIORefNum; {reference number}
562 ioFVersNum: SInt8; {version number}
563 filler1: SInt8;
564 ioFDirIndex: SInt16; {GetFInfo directory index}
565 ioFlAttrib: SInt8; {GetFInfo: in-use bit=7, lock bit=0}
566 ioFlVersNum: SInt8; {file version number}
567 ioFlFndrInfo: FInfo; {user info}
568 ioFlNum: UInt32; {GetFInfo: file number; TF- ioDirID}
569 ioFlStBlk: UInt16; {start file block (0 if none)}
570 ioFlLgLen: SInt32; {logical length (EOF)}
571 ioFlPyLen: SInt32; {physical length}
572 ioFlRStBlk: UInt16; {start block rsrc fork}
573 ioFlRLgLen: SInt32; {file logical length rsrc fork}
574 ioFlRPyLen: SInt32; {file physical length rsrc fork}
575 ioFlCrDat: UInt32; {file creation date& time (32 bits in secs)}
576 ioFlMdDat: UInt32; {last modified date and time}
577 end;
578 FileParamPtr = ^FileParam;
579
580 VolumeParam = record
581 qLink: QElemPtr; {queue link in header}
582 qType: SInt16; {type byte for safety check}
583 ioTrap: SInt16; {FS: the Trap}
584 ioCmdAddr: Ptr; {FS: address to dispatch to}
585 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
586 ioResult: {volatile} OSErr; {result code}
587 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
588 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
589 filler2: UInt32;
590 ioVolIndex: SInt16; {volume index number}
591 ioVCrDate: UInt32; {creation date and time}
592 ioVLsBkUp: UInt32; {last backup date and time}
593 ioVAtrb: UInt16; {volume attrib}
594 ioVNmFls: UInt16; {number of files in directory}
595 ioVDirSt: UInt16; {start block of file directory}
596 ioVBlLn: SInt16; {GetVolInfo: length of dir in blocks}
597 ioVNmAlBlks: UInt16; {for compatibilty ioVNmAlBlks * ioVAlBlkSiz <= 2 GB}
598 ioVAlBlkSiz: UInt32; {for compatibilty ioVAlBlkSiz is <= $0000FE00 (65,024)}
599 ioVClpSiz: UInt32; {GetVolInfo: bytes to allocate at a time}
600 ioAlBlSt: UInt16; {starting disk(512-byte) block in block map}
601 ioVNxtFNum: UInt32; {GetVolInfo: next free file number}
602 ioVFrBlk: UInt16; {GetVolInfo: # free alloc blks for this vol}
603 end;
604 VolumeParamPtr = ^VolumeParam;
605
606 CntrlParam = record
607 qLink: QElemPtr; {queue link in header}
608 qType: SInt16; {type byte for safety check}
609 ioTrap: SInt16; {FS: the Trap}
610 ioCmdAddr: Ptr; {FS: address to dispatch to}
611 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
612 ioResult: {volatile} OSErr; {result code}
613 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
614 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
615 ioCRefNum: FSIORefNum; {refNum for I/O operation}
616 csCode: SInt16; {word for control status code}
617 csParam: array [0..10] of SInt16; { operation-defined parameters }
618 end;
619 CntrlParamPtr = ^CntrlParam;
620
621 SlotDevParam = record
622 qLink: QElemPtr; {queue link in header}
623 qType: SInt16; {type byte for safety check}
624 ioTrap: SInt16; {FS: the Trap}
625 ioCmdAddr: Ptr; {FS: address to dispatch to}
626 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
627 ioResult: {volatile} OSErr; {result code}
628 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
629 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
630 ioSRefNum: FSIORefNum;
631 ioSVersNum: SInt8;
632 ioSPermssn: SInt8;
633 ioSMix: Ptr;
634 ioSFlags: SInt16;
635 ioSlot: SInt8;
636 ioID: SInt8;
637 end;
638 SlotDevParamPtr = ^SlotDevParam;
639
640 MultiDevParam = record
641 qLink: QElemPtr; {queue link in header}
642 qType: SInt16; {type byte for safety check}
643 ioTrap: SInt16; {FS: the Trap}
644 ioCmdAddr: Ptr; {FS: address to dispatch to}
645 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
646 ioResult: {volatile} OSErr; {result code}
647 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
648 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
649 ioMRefNum: FSIORefNum;
650 ioMVersNum: SInt8;
651 ioMPermssn: SInt8;
652 ioMMix: Ptr;
653 ioMFlags: SInt16;
654 ioSEBlkPtr: Ptr;
655 end;
656 MultiDevParamPtr = ^MultiDevParam;
657
658 ParamBlockRecPtr = ^ParamBlockRec;
659 ParamBlockRec = record
660 qLink: QElemPtr; {queue link in header}
661 qType: SInt16; {type byte for safety check}
662 ioTrap: SInt16; {FS: the Trap}
663 ioCmdAddr: Ptr; {FS: address to dispatch to}
664 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
665 ioResult: {volatile} OSErr; {result code}
666 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
667 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
668 case SInt16 of
669 0: (
670 ioRefNum: FSIORefNum; { refNum for I/O operation }
671 ioVersNum: SInt8; { version number }
672 ioPermssn: SInt8; { Open: permissions (byte) }
673 ioMisc: Ptr; { Rename: new name (GetEOF,SetEOF: logical end of file) (Open: optional ptr to buffer) (SetFileType: new type) }
674 ioBuffer: Ptr; { data buffer Ptr }
675 ioReqCount: SInt32; { requested byte count; also = ioNewDirID }
676 ioActCount: SInt32; { actual byte count completed }
677 ioPosMode: SInt16; { initial file positioning }
678 ioPosOffset: SInt32; { file position offset }
679 );
680 1: (
681 ioFRefNum: FSIORefNum; { reference number }
682 ioFVersNum: SInt8; { version number }
683 filler1: SInt8;
684 ioFDirIndex: SInt16; { GetFInfo directory index }
685 ioFlAttrib: SInt8; { GetFInfo: in-use bit=7, lock bit=0 }
686 ioFlVersNum: SInt8; { file version number }
687 ioFlFndrInfo: FInfo; { user info }
688 ioFlNum: UInt32; { GetFInfo: file number; TF- ioDirID }
689 ioFlStBlk: UInt16; { start file block (0 if none) }
690 ioFlLgLen: SInt32; { logical length (EOF) }
691 ioFlPyLen: SInt32; { physical length }
692 ioFlRStBlk: UInt16; { start block rsrc fork }
693 ioFlRLgLen: SInt32; { file logical length rsrc fork }
694 ioFlRPyLen: SInt32; { file physical length rsrc fork }
695 ioFlCrDat: UInt32; { file creation date& time (32 bits in secs) }
696 ioFlMdDat: UInt32; { last modified date and time }
697 );
698 2: (
699 filler2: SInt32;
700 ioVolIndex: SInt16; { volume index number }
701 ioVCrDate: UInt32; { creation date and time }
702 ioVLsBkUp: UInt32; { last backup date and time }
703 ioVAtrb: UInt16; { volume attrib }
704 ioVNmFls: UInt16; { number of files in directory }
705 ioVDirSt: UInt16; { start block of file directory }
706 ioVBlLn: SInt16; { GetVolInfo: length of dir in blocks }
707 ioVNmAlBlks: UInt16; { for compatibilty ioVNmAlBlks * ioVAlBlkSiz <= 2 GB }
708 ioVAlBlkSiz: UInt32; { for compatibilty ioVAlBlkSiz is <= $0000FE00 (65,024) }
709 ioVClpSiz: UInt32; { GetVolInfo: bytes to allocate at a time }
710 ioAlBlSt: UInt16; { starting disk(512-byte) block in block map }
711 ioVNxtFNum: UInt32; { GetVolInfo: next free file number }
712 ioVFrBlk: UInt16; { GetVolInfo: # free alloc blks for this vol }
713 );
714 3: (
715 ioCRefNum: SInt16; { refNum for I/O operation }
716 csCode: SInt16; { word for control status code }
717 csParam: array [0..10] of SInt16; { operation-defined parameters }
718 );
719 4: (
720 ioSRefNum: SInt16;
721 ioSVersNum: SInt8;
722 ioSPermssn: SInt8;
723 ioSMix: Ptr;
724 ioSFlags: SInt16;
725 ioSlot: SInt8;
726 ioID: SInt8;
727 );
728 5: (
729 ioMRefNum: SInt16;
730 ioMVersNum: SInt8;
731 ioMPermssn: SInt8;
732 ioMMix: Ptr;
733 ioMFlags: SInt16;
734 ioSEBlkPtr: Ptr;
735 );
736 end;
737
738 CInfoPBRecPtr = ^CInfoPBRec;
739 CInfoPBRec = record
740 qLink: QElemPtr; { queue link in header }
741 qType: SInt16; { type byte for safety check }
742 ioTrap: SInt16; { FS: the Trap }
743 ioCmdAddr: Ptr; { FS: address to dispatch to }
744 ioCompletion: IOCompletionUPP; { completion routine addr (0 for synch calls) }
745 ioResult: {volatile} OSErr; { result code }
746 ioNamePtr: StringPtr; { ptr to Vol:FileName string }
747 ioVRefNum: FSVolumeRefNum; { volume refnum (DrvNum for Eject and MountVol) }
748 ioFRefNum: FSIORefNum;
749 ioFVersNum: SInt8;
750 filler1: SInt8;
751 ioFDirIndex: SInt16;
752 ioFlAttrib: SInt8;
753 ioACUser: SInt8;
754 case SInt16 of
755 0: (
756 ioFlFndrInfo: FInfo;
757 ioDirID: UInt32;
758 ioFlStBlk: UInt16;
759 ioFlLgLen: SInt32;
760 ioFlPyLen: SInt32;
761 ioFlRStBlk: UInt16;
762 ioFlRLgLen: SInt32;
763 ioFlRPyLen: SInt32;
764 ioFlCrDat: UInt32;
765 ioFlMdDat: UInt32;
766 ioFlBkDat: UInt32;
767 ioFlXFndrInfo: FXInfo;
768 ioFlParID: UInt32;
769 ioFlClpSiz: SInt32;
770 );
771 1: (
772 ioDrUsrWds: DInfo;
773 ioDrDirID: SInt32;
774 ioDrNmFls: UInt16;
775 filler3: array [1..9] of SInt16;
776 ioDrCrDat: UInt32;
777 ioDrMdDat: UInt32;
778 ioDrBkDat: UInt32;
779 ioDrFndrInfo: DXInfo;
780 ioDrParID: SInt32;
781 );
782 end;
783
784
785 type
786 CInfoPBPtr = CInfoPBRecPtr;
787 XCInfoPBRecPtr = ^XCInfoPBRec;
788 XCInfoPBRec = record
789 qLink: QElemPtr;
790 qType: SInt16;
791 ioTrap: SInt16;
792 ioCmdAddr: Ptr;
793 ioCompletion: ProcPtr; { --> A pointer to a completion routine }
794 ioResult: {volatile} OSErr; { --> The result code of the function }
795 ioNamePtr: StringPtr; { --> Pointer to pathname to object }
796 ioVRefNum: FSVolumeRefNum; { --> A volume specification }
797 filler1: SInt32;
798 ioShortNamePtr: StringPtr; { <-> A pointer to the short name string buffer - required! }
799 filler2: SInt16;
800 ioPDType: SInt16; { <-- The ProDOS file type }
801 ioPDAuxType: SInt32; { <-- The ProDOS aux type }
802 filler3: array [0..1] of SInt32;
803 ioDirID: SInt32; { --> A directory ID }
804 end;
805 type
806 XCInfoPBPtr = XCInfoPBRecPtr;
807 {
808 The following are structures to be filled out with the _PBGetVolMountInfo call
809 and passed back into the _PBVolumeMount call for external file system mounts.
810 }
811 DTPBRecPtr = ^DTPBRec;
812 DTPBRec = record
813 qLink: QElemPtr; {queue link in header}
814 qType: SInt16; {type byte for safety check}
815 ioTrap: SInt16; {FS: the Trap}
816 ioCmdAddr: Ptr; {FS: address to dispatch to}
817 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
818 ioResult: {volatile} OSErr; {result code}
819 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
820 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
821 ioDTRefNum: FSIORefNum; { desktop refnum }
822 ioIndex: SInt16;
823 ioTagInfo: SInt32;
824 ioDTBuffer: Ptr;
825 ioDTReqCount: SInt32;
826 ioDTActCount: SInt32;
827 ioFiller1: SInt8;
828 ioIconType: UInt8;
829 ioFiller2: SInt16;
830 ioDirID: SInt32;
831 ioFileCreator: OSType;
832 ioFileType: OSType;
833 ioFiller3: SInt32;
834 ioDTLgLen: SInt32;
835 ioDTPyLen: SInt32;
836 ioFiller4: array [1..14] of SInt16;
837 ioAPPLParID: SInt32;
838 end;
839 type
840 DTPBPtr = DTPBRecPtr;
841
842 type
843 HIOParam = record
844 qLink: QElemPtr; {queue link in header}
845 qType: SInt16; {type byte for safety check}
846 ioTrap: SInt16; {FS: the Trap}
847 ioCmdAddr: Ptr; {FS: address to dispatch to}
848 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
849 ioResult: {volatile} OSErr; {result code}
850 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
851 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
852 ioRefNum: FSIORefNum;
853 ioVersNum: SInt8;
854 ioPermssn: SInt8;
855 ioMisc: Ptr;
856 ioBuffer: Ptr;
857 ioReqCount: SInt32;
858 ioActCount: SInt32;
859 ioPosMode: SInt16;
860 ioPosOffset: SInt32;
861 end;
862 HIOParamPtr = ^HIOParam;
863 type
864 HFileParam = record
865 qLink: QElemPtr; {queue link in header}
866 qType: SInt16; {type byte for safety check}
867 ioTrap: SInt16; {FS: the Trap}
868 ioCmdAddr: Ptr; {FS: address to dispatch to}
869 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
870 ioResult: {volatile} OSErr; {result code}
871 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
872 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
873 ioFRefNum: FSIORefNum;
874 ioFVersNum: SInt8;
875 filler1: SInt8;
876 ioFDirIndex: SInt16;
877 ioFlAttrib: SInt8;
878 ioFlVersNum: SInt8;
879 ioFlFndrInfo: FInfo;
880 ioDirID: SInt32;
881 ioFlStBlk: UInt16;
882 ioFlLgLen: SInt32;
883 ioFlPyLen: SInt32;
884 ioFlRStBlk: UInt16;
885 ioFlRLgLen: SInt32;
886 ioFlRPyLen: SInt32;
887 ioFlCrDat: UInt32;
888 ioFlMdDat: UInt32;
889 end;
890 HFileParamPtr = ^HFileParam;
891 type
892 HVolumeParam = record
893 qLink: QElemPtr; {queue link in header}
894 qType: SInt16; {type byte for safety check}
895 ioTrap: SInt16; {FS: the Trap}
896 ioCmdAddr: Ptr; {FS: address to dispatch to}
897 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
898 ioResult: {volatile} OSErr; {result code}
899 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
900 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
901 filler2: SInt32;
902 ioVolIndex: SInt16;
903 ioVCrDate: UInt32;
904 ioVLsMod: UInt32;
905 ioVAtrb: SInt16;
906 ioVNmFls: UInt16;
907 ioVBitMap: UInt16;
908 ioAllocPtr: UInt16;
909 ioVNmAlBlks: UInt16;
910 ioVAlBlkSiz: UInt32;
911 ioVClpSiz: UInt32;
912 ioAlBlSt: UInt16;
913 ioVNxtCNID: UInt32;
914 ioVFrBlk: UInt16;
915 ioVSigWord: UInt16;
916 ioVDrvInfo: SInt16;
917 ioVDRefNum: FSIORefNum;
918 ioVFSID: SInt16;
919 ioVBkUp: UInt32;
920 ioVSeqNum: SInt16;
921 ioVWrCnt: UInt32;
922 ioVFilCnt: UInt32;
923 ioVDirCnt: UInt32;
924 ioVFndrInfo: array [1..8] of SInt32;
925 end;
926 HVolumeParamPtr = ^HVolumeParam;
927 type
928 XIOParam = record
929 qLink: QElemPtr; {queue link in header}
930 qType: SInt16; {type byte for safety check}
931 ioTrap: SInt16; {FS: the Trap}
932 ioCmdAddr: Ptr; {FS: address to dispatch to}
933 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
934 ioResult: {volatile} OSErr; {result code}
935 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
936 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
937 ioRefNum: FSIORefNum;
938 ioVersNum: SInt8;
939 ioPermssn: SInt8;
940 ioMisc: Ptr;
941 ioBuffer: Ptr;
942 ioReqCount: SInt32;
943 ioActCount: SInt32;
944 ioPosMode: SInt16; { must have kUseWidePositioning bit set }
945 ioWPosOffset: wide; { wide positioning offset }
946 end;
947 XIOParamPtr = ^XIOParam;
948 type
949 XVolumeParam = record
950 qLink: QElemPtr; {queue link in header}
951 qType: SInt16; {type byte for safety check}
952 ioTrap: SInt16; {FS: the Trap}
953 ioCmdAddr: Ptr; {FS: address to dispatch to}
954 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
955 ioResult: {volatile} OSErr; {result code}
956 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
957 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
958 ioXVersion: UInt32; { this XVolumeParam version (0) }
959 ioVolIndex: SInt16;
960 ioVCrDate: UInt32;
961 ioVLsMod: UInt32;
962 ioVAtrb: SInt16;
963 ioVNmFls: UInt16;
964 ioVBitMap: UInt16;
965 ioAllocPtr: UInt16;
966 ioVNmAlBlks: UInt16;
967 ioVAlBlkSiz: UInt32;
968 ioVClpSiz: UInt32;
969 ioAlBlSt: UInt16;
970 ioVNxtCNID: UInt32;
971 ioVFrBlk: UInt16;
972 ioVSigWord: UInt16;
973 ioVDrvInfo: SInt16;
974 ioVDRefNum: SInt16;
975 ioVFSID: SInt16;
976 ioVBkUp: UInt32;
977 ioVSeqNum: SInt16;
978 ioVWrCnt: UInt32;
979 ioVFilCnt: UInt32;
980 ioVDirCnt: UInt32;
981 ioVFndrInfo: array [1..8] of SInt32;
982 ioVTotalBytes: UInt64; { total number of bytes on volume }
983 ioVFreeBytes: UInt64; { number of free bytes on volume }
984 end;
985 XVolumeParamPtr = ^XVolumeParam;
986 type
987 AccessParam = record
988 qLink: QElemPtr; {queue link in header}
989 qType: SInt16; {type byte for safety check}
990 ioTrap: SInt16; {FS: the Trap}
991 ioCmdAddr: Ptr; {FS: address to dispatch to}
992 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
993 ioResult: {volatile} OSErr; {result code}
994 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
995 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
996 ioRefNum: FSIORefNum; { <- , ioRefNum ( use to be filler3 ) }
997 ioDenyModes: SInt16; {access rights data}
998 filler4: SInt16;
999 filler5: SInt8;
1000 ioACUser: SInt8; {access rights for directory only}
1001 filler6: SInt32;
1002 ioACOwnerID: SInt32; {owner ID}
1003 ioACGroupID: SInt32; {group ID}
1004 ioACAccess: SInt32; {access rights}
1005 ioDirID: SInt32;
1006 end;
1007 AccessParamPtr = ^AccessParam;
1008 type
1009 ObjParam = record
1010 qLink: QElemPtr; {queue link in header}
1011 qType: SInt16; {type byte for safety check}
1012 ioTrap: SInt16; {FS: the Trap}
1013 ioCmdAddr: Ptr; {FS: address to dispatch to}
1014 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1015 ioResult: {volatile} OSErr; {result code}
1016 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1017 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1018 filler7: SInt16;
1019 ioObjType: SInt16; {function code}
1020 ioObjNamePtr: StringPtr; {ptr to returned creator/group name}
1021 ioObjID: SInt32; {creator/group ID}
1022 end;
1023 ObjParamPtr = ^ObjParam;
1024 type
1025 CopyParam = record
1026 qLink: QElemPtr; {queue link in header}
1027 qType: SInt16; {type byte for safety check}
1028 ioTrap: SInt16; {FS: the Trap}
1029 ioCmdAddr: Ptr; {FS: address to dispatch to}
1030 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1031 ioResult: {volatile} OSErr; {result code}
1032 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1033 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1034 ioDstVRefNum: FSVolumeRefNum; {destination vol identifier}
1035 filler8: SInt16;
1036 ioNewName: StringPtr; {ptr to destination pathname}
1037 ioCopyName: StringPtr; {ptr to optional name}
1038 ioNewDirID: SInt32; {destination directory ID}
1039 filler14: SInt32;
1040 filler15: SInt32;
1041 ioDirID: SInt32;
1042 end;
1043 CopyParamPtr = ^CopyParam;
1044 type
1045 WDParam = record
1046 qLink: QElemPtr; {queue link in header}
1047 qType: SInt16; {type byte for safety check}
1048 ioTrap: SInt16; {FS: the Trap}
1049 ioCmdAddr: Ptr; {FS: address to dispatch to}
1050 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1051 ioResult: {volatile} OSErr; {result code}
1052 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1053 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1054 ioWDCreated: SInt16;
1055 ioWDIndex: SInt16;
1056 ioWDProcID: SInt32;
1057 ioWDVRefNum: FSVolumeRefNum;
1058 filler10: SInt16;
1059 filler11: SInt32;
1060 filler12: SInt32;
1061 filler13: SInt32;
1062 ioWDDirID: SInt32;
1063 end;
1064 WDParamPtr = ^WDParam;
1065 type
1066 FIDParam = record
1067 qLink: QElemPtr; {queue link in header}
1068 qType: SInt16; {type byte for safety check}
1069 ioTrap: SInt16; {FS: the Trap}
1070 ioCmdAddr: Ptr; {FS: address to dispatch to}
1071 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1072 ioResult: {volatile} OSErr; {result code}
1073 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1074 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1075 filler14: SInt32;
1076 ioDestNamePtr: StringPtr; { dest file name }
1077 filler15: SInt32;
1078 ioDestDirID: SInt32; { dest file's directory id }
1079 filler16: SInt32;
1080 filler17: SInt32;
1081 ioSrcDirID: SInt32; { source file's directory id }
1082 filler18: SInt16;
1083 ioFileID: SInt32; { file ID }
1084 end;
1085 FIDParamPtr = ^FIDParam;
1086 type
1087 ForeignPrivParam = record
1088 qLink: QElemPtr; {queue link in header}
1089 qType: SInt16; {type byte for safety check}
1090 ioTrap: SInt16; {FS: the Trap}
1091 ioCmdAddr: Ptr; {FS: address to dispatch to}
1092 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1093 ioResult: {volatile} OSErr; {result code}
1094 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1095 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1096 ioFiller21: SInt32;
1097 ioFiller22: SInt32;
1098 ioForeignPrivBuffer: Ptr;
1099 ioForeignPrivActCount: SInt32;
1100 ioForeignPrivReqCount: SInt32;
1101 ioFiller23: SInt32;
1102 ioForeignPrivDirID: SInt32;
1103 ioForeignPrivInfo1: SInt32;
1104 ioForeignPrivInfo2: SInt32;
1105 ioForeignPrivInfo3: SInt32;
1106 ioForeignPrivInfo4: SInt32;
1107 end;
1108 ForeignPrivParamPtr = ^ForeignPrivParam;
1109 type
1110 CSParam = record
1111 qLink: QElemPtr; {queue link in header}
1112 qType: SInt16; {type byte for safety check}
1113 ioTrap: SInt16; {FS: the Trap}
1114 ioCmdAddr: Ptr; {FS: address to dispatch to}
1115 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1116 ioResult: {volatile} OSErr; {result code}
1117 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1118 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1119 ioMatchPtr: FSSpecPtr; { match array }
1120 ioReqMatchCount: SInt32; { maximum allowable matches }
1121 ioActMatchCount: SInt32; { actual match count }
1122 ioSearchBits: SInt32; { search criteria selector }
1123 ioSearchInfo1: CInfoPBPtr; { search values and range lower bounds }
1124 ioSearchInfo2: CInfoPBPtr; { search values and range upper bounds }
1125 ioSearchTime: SInt32; { length of time to run search }
1126 ioCatPosition: CatPositionRec; { current position in the catalog }
1127 ioOptBuffer: Ptr; { optional performance enhancement buffer }
1128 ioOptBufSize: SInt32; { size of buffer pointed to by ioOptBuffer }
1129 end;
1130 CSParamPtr = ^CSParam;
1131
1132 type
1133 HParamBlockRecPtr = ^HParamBlockRec;
1134 HParamBlockRec = record
1135 qLink: QElemPtr; { queue link in header }
1136 qType: SInt16; { type byte for safety check }
1137 ioTrap: SInt16; { FS: the Trap }
1138 ioCmdAddr: Ptr; { FS: address to dispatch to }
1139 ioCompletion: IOCompletionUPP; { completion routine addr (0 for synch calls) }
1140 ioResult: OSErr; { result code }
1141 ioNamePtr: StringPtr; { ptr to Vol:FileName string }
1142 ioVRefNum: FSVolumeRefNum; { volume refnum (DrvNum for Eject and MountVol) }
1143 case SInt16 of
1144 0: (
1145 ioRefNum: FSIORefNum;
1146 ioVersNum: SInt8;
1147 ioPermssn: SInt8;
1148 ioMisc: Ptr;
1149 ioBuffer: Ptr;
1150 ioReqCount: SInt32;
1151 ioActCount: SInt32;
1152 ioPosMode: SInt16;
1153 ioPosOffset: SInt32;
1154 );
1155 1: (
1156 ioFRefNum: FSIORefNum;
1157 ioFVersNum: SInt8;
1158 filler1: SInt8;
1159 ioFDirIndex: SInt16;
1160 ioFlAttrib: SInt8;
1161 ioFlVersNum: SInt8;
1162 ioFlFndrInfo: FInfo;
1163 ioDirID: SInt32;
1164 ioFlStBlk: UInt16;
1165 ioFlLgLen: SInt32;
1166 ioFlPyLen: SInt32;
1167 ioFlRStBlk: UInt16;
1168 ioFlRLgLen: SInt32;
1169 ioFlRPyLen: SInt32;
1170 ioFlCrDat: UInt32;
1171 ioFlMdDat: UInt32;
1172 );
1173 2: (
1174 filler2: SInt32;
1175 ioVolIndex: SInt16;
1176 ioVCrDate: UInt32;
1177 ioVLsMod: UInt32;
1178 ioVAtrb: SInt16;
1179 ioVNmFls: UInt16;
1180 ioVBitMap: UInt16;
1181 ioAllocPtr: UInt16;
1182 ioVNmAlBlks: UInt16;
1183 ioVAlBlkSiz: UInt32;
1184 ioVClpSiz: UInt32;
1185 ioAlBlSt: UInt16;
1186 ioVNxtCNID: UInt32;
1187 ioVFrBlk: UInt16;
1188 ioVSigWord: UInt16;
1189 ioVDrvInfo: SInt16;
1190 ioVDRefNum: FSIORefNum;
1191 ioVFSID: SInt16;
1192 ioVBkUp: UInt32;
1193 ioVSeqNum: UInt16;
1194 ioVWrCnt: UInt32;
1195 ioVFilCnt: UInt32;
1196 ioVDirCnt: UInt32;
1197 ioVFndrInfo: array [1..8] of SInt32;
1198 );
1199 3: (
1200 filler3: SInt16;
1201 ioDenyModes: SInt16; { access rights data }
1202 filler4: SInt16;
1203 filler5: SInt8;
1204 ioACUser: SInt8; { access rights for directory only }
1205 filler6: SInt32;
1206 ioACOwnerID: SInt32; { owner ID }
1207 ioACGroupID: SInt32; { group ID }
1208 ioACAccess: SInt32; { access rights }
1209 { ioDirID: SInt32; -- since this struct is only defined for 32 bit targets, the ioDirID field from case 1 will be at the same address }
1210 );
1211 4: (
1212 filler7: SInt16;
1213 ioObjType: SInt16; { function code }
1214 ioObjNamePtr: StringPtr; { ptr to returned creator/group name }
1215 ioObjID: SInt32; { creator/group ID }
1216 );
1217 5: (
1218 ioDstVRefNum: SInt16; { destination vol identifier }
1219 filler8: SInt16;
1220 ioNewName: StringPtr; { ptr to destination pathname }
1221 ioCopyName: StringPtr; { ptr to optional name }
1222 ioNewDirID: SInt32; { destination directory ID }
1223 { filler14: SInt32;
1224 filler15: SInt32;
1225 ioDirID: SInt32; -- since this struct is only defined for 32 bit targets, the ioDirID field from case 1 will be at the same address }
1226 );
1227 6: (
1228 ioWDCreated: SInt16;
1229 ioWDIndex: SInt16;
1230 ioWDProcID: SInt32;
1231 ioWDVRefNum: FSVolumeRefNum;
1232 filler10: SInt16;
1233 filler11: SInt32;
1234 filler12: SInt32;
1235 filler13: SInt32;
1236 ioWDDirID: SInt32;
1237 );
1238 7: (
1239 filler14: SInt32;
1240 ioDestNamePtr: StringPtr; { dest file name }
1241 filler15: SInt32;
1242 ioDestDirID: SInt32; { dest file's directory id }
1243 filler16: SInt32;
1244 filler17: SInt32;
1245 ioSrcDirID: SInt32; { source file's directory id }
1246 filler18: SInt16;
1247 ioFileID: SInt32; { file ID }
1248 );
1249 8: (
1250 ioMatchPtr: FSSpecPtr; { match array }
1251 ioReqMatchCount: SInt32; { maximum allowable matches }
1252 ioActMatchCount: SInt32; { actual match count }
1253 ioSearchBits: SInt32; { search criteria selector }
1254 ioSearchInfo1: CInfoPBPtr; { search values and range lower bounds }
1255 ioSearchInfo2: CInfoPBPtr; { search values and range upper bounds }
1256 ioSearchTime: SInt32; { length of time to run search }
1257 ioCatPosition: CatPositionRec; { current position in the catalog }
1258 ioOptBuffer: Ptr; { optional performance enhancement buffer }
1259 ioOptBufSize: SInt32; { size of buffer pointed to by ioOptBuffer }
1260 );
1261 9: (
1262 ioFiller21: SInt32;
1263 ioFiller22: SInt32;
1264 ioForeignPrivBuffer: Ptr;
1265 ioForeignPrivActCount: SInt32;
1266 ioForeignPrivReqCount: SInt32;
1267 ioFiller23: SInt32;
1268 ioForeignPrivDirID: SInt32;
1269 ioForeignPrivInfo1: SInt32;
1270 ioForeignPrivInfo2: SInt32;
1271 ioForeignPrivInfo3: SInt32;
1272 ioForeignPrivInfo4: SInt32;
1273 );
1274 end;
1275
1276 HParmBlkPtr = ^HParamBlockRec;
1277
1278 type
1279 CMovePBRecPtr = ^CMovePBRec;
1280 CMovePBRec = record
1281 qLink: QElemPtr; {queue link in header}
1282 qType: SInt16; {type byte for safety check}
1283 ioTrap: SInt16; {FS: the Trap}
1284 ioCmdAddr: Ptr; {FS: address to dispatch to}
1285 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1286 ioResult: {volatile} OSErr; {result code}
1287 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1288 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1289 filler1: SInt32;
1290 ioNewName: StringPtr;
1291 filler2: SInt32;
1292 ioNewDirID: SInt32;
1293 filler3: array [1..2] of SInt32;
1294 ioDirID: SInt32;
1295 end;
1296
1297 CMovePBPtr = CMovePBRecPtr;
1298 WDPBRecPtr = ^WDPBRec;
1299 WDPBRec = record
1300 qLink: QElemPtr; {queue link in header}
1301 qType: SInt16; {type byte for safety check}
1302 ioTrap: SInt16; {FS: the Trap}
1303 ioCmdAddr: Ptr; {FS: address to dispatch to}
1304 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1305 ioResult: {volatile} OSErr; {result code}
1306 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1307 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1308 filler1: SInt16;
1309 ioWDIndex: SInt16;
1310 ioWDProcID: SInt32;
1311 ioWDVRefNum: FSVolumeRefNum;
1312 filler2: array [1..7] of SInt16;
1313 ioWDDirID: SInt32;
1314 end;
1315 type
1316 WDPBPtr = WDPBRecPtr;
1317 FCBPBRecPtr = ^FCBPBRec;
1318 FCBPBRec = record
1319 qLink: QElemPtr; {queue link in header}
1320 qType: SInt16; {type byte for safety check}
1321 ioTrap: SInt16; {FS: the Trap}
1322 ioCmdAddr: Ptr; {FS: address to dispatch to}
1323 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1324 ioResult: {volatile} OSErr; {result code}
1325 ioNamePtr: StringPtr; {ptr to Vol:FileName string}
1326 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1327 ioRefNum: FSIORefNum;
1328 filler: SInt16;
1329 ioFCBIndx: SInt16;
1330 filler1: SInt16;
1331 ioFCBFlNm: SInt32;
1332 ioFCBFlags: SInt16;
1333 ioFCBStBlk: UInt16;
1334 ioFCBEOF: SInt32;
1335 ioFCBPLen: SInt32;
1336 ioFCBCrPs: SInt32;
1337 ioFCBVRefNum: FSVolumeRefNum;
1338 ioFCBClpSiz: SInt32;
1339 ioFCBParID: SInt32;
1340 end;
1341 type
1342 FCBPBPtr = FCBPBRecPtr;
1343 VCB = record
1344 qLink: QElemPtr;
1345 qType: SInt16;
1346 vcbFlags: SInt16;
1347 vcbSigWord: UInt16;
1348 vcbCrDate: UInt32;
1349 vcbLsMod: UInt32;
1350 vcbAtrb: SInt16;
1351 vcbNmFls: UInt16;
1352 vcbVBMSt: SInt16;
1353 vcbAllocPtr: SInt16;
1354 vcbNmAlBlks: UInt16;
1355 vcbAlBlkSiz: SInt32;
1356 vcbClpSiz: SInt32;
1357 vcbAlBlSt: SInt16;
1358 vcbNxtCNID: SInt32;
1359 vcbFreeBks: UInt16;
1360 vcbVN: Str27;
1361 vcbDrvNum: SInt16;
1362 vcbDRefNum: FSIORefNum;
1363 vcbFSID: SInt16;
1364 vcbVRefNum: FSVolumeRefNum;
1365 vcbMAdr: Ptr;
1366 vcbBufAdr: Ptr;
1367 vcbMLen: SInt16;
1368 vcbDirIndex: SInt16;
1369 vcbDirBlk: SInt16;
1370 vcbVolBkUp: UInt32;
1371 vcbVSeqNum: UInt16;
1372 vcbWrCnt: SInt32;
1373 vcbXTClpSiz: SInt32;
1374 vcbCTClpSiz: SInt32;
1375 vcbNmRtDirs: UInt16;
1376 vcbFilCnt: SInt32;
1377 vcbDirCnt: SInt32;
1378 vcbFndrInfo: array [1..8] of SInt32;
1379 vcbVCSize: UInt16;
1380 vcbVBMCSiz: UInt16;
1381 vcbCtlCSiz: UInt16;
1382 vcbXTAlBlks: UInt16;
1383 vcbCTAlBlks: UInt16;
1384 vcbXTRef: SInt16;
1385 vcbCTRef: SInt16;
1386 vcbCtlBuf: Ptr;
1387 vcbDirIDM: SInt32;
1388 vcbOffsM: SInt16;
1389 end;
1390 VCBPtr = ^VCB;
1391 type
1392 DrvQEl = record
1393 qLink: QElemPtr;
1394 qType: SInt16;
1395 dQDrive: SInt16;
1396 dQRefNum: SInt16;
1397 dQFSID: SInt16;
1398 dQDrvSz: UInt16;
1399 dQDrvSz2: UInt16;
1400 end;
1401 DrvQElPtr = ^DrvQEl;
1402 {$endc} {not TARGET_CPU_64}
1403
1404
1405 {
1406 * FSPermissionInfo
1407 *
1408 * Discussion:
1409 * This structure is used when kFSCatInfoPermissions is passed to
1410 * the HFSPlus API. On return from GetCatalogInfo and
1411 * GetCatalogInfoBulk, the userID, groupID, and mode fields are
1412 * returned. When passed to SetCatalogInfo, only the mode field is
1413 * set. See chmod(2) for details about the mode field. This is
1414 * supported on Mac OS X only. NOTE: An FSFileSecurityRef retrieved
1415 * via FSGetCatalogInfo is a copy and must be released using
1416 * CFRelease() when no longer needed.
1417 }
1418 type
1419 FSPermissionInfoPtr = ^FSPermissionInfo;
1420 FSPermissionInfo = record
1421 userID: UInt32;
1422 groupID: UInt32;
1423 reserved1: UInt8;
1424 userAccess: UInt8;
1425 mode: UInt16;
1426 fileSec: FSFileSecurityRef;
1427 end;
1428 { CatalogInfoBitmap describes which fields of the CatalogInfo you wish to get or set.}
1429
1430 type
1431 FSCatalogInfoBitmap = UInt32;
1432 const
1433 kFSCatInfoNone = $00000000;
1434 kFSCatInfoTextEncoding = $00000001;
1435 kFSCatInfoNodeFlags = $00000002; { Locked (bit 0) and directory (bit 4) only }
1436 kFSCatInfoVolume = $00000004;
1437 kFSCatInfoParentDirID = $00000008;
1438 kFSCatInfoNodeID = $00000010;
1439 kFSCatInfoCreateDate = $00000020;
1440 kFSCatInfoContentMod = $00000040;
1441 kFSCatInfoAttrMod = $00000080;
1442 kFSCatInfoAccessDate = $00000100; { Note: although included in kFSCatInfoSettableInfo, attempts to set kFSCatInfoAccessDate will do nothing but will not cause an error }
1443 kFSCatInfoBackupDate = $00000200;
1444 kFSCatInfoPermissions = $00000400;
1445 kFSCatInfoFinderInfo = $00000800;
1446 kFSCatInfoFinderXInfo = $00001000;
1447 kFSCatInfoValence = $00002000; { Folders only, zero for files }
1448 kFSCatInfoDataSizes = $00004000; { Data fork logical and physical size }
1449 kFSCatInfoRsrcSizes = $00008000; { Resource fork logical and physical size }
1450 kFSCatInfoSharingFlags = $00010000; { sharingFlags: kioFlAttribMountedBit, kioFlAttribSharePointBit }
1451 kFSCatInfoUserPrivs = $00020000; { userPrivileges }
1452 kFSCatInfoUserAccess = $00080000; { (OS X only) }
1453 kFSCatInfoSetOwnership = $00100000; { (OS X only) }
1454 kFSCatInfoFSFileSecurityRef = $00400000; { FSFileSecurity Object, will show up in the permissions field independent of kFSCatInfoPermissions. This is also not part of settable, gettable since it requires being released }
1455 kFSCatInfoAllDates = $000003E0;
1456 kFSCatInfoGettableInfo = $0003FFFF;
1457 kFSCatInfoSettableInfo = $00001FE3; { flags, dates, permissions, Finder info, text encoding }
1458 kFSCatInfoReserved = -262144 ; { SInt32($FFFC0000) -- bits that are currently reserved }
1459
1460 { Constants for nodeFlags field of FSCatalogInfo }
1461 const
1462 kFSNodeLockedBit = 0; { Set if file or directory is locked }
1463 kFSNodeLockedMask = $0001;
1464 kFSNodeResOpenBit = 2; { Set if the resource fork is open }
1465 kFSNodeResOpenMask = $0004;
1466 kFSNodeDataOpenBit = 3; { Set if the data fork is open }
1467 kFSNodeDataOpenMask = $0008;
1468 kFSNodeIsDirectoryBit = 4; { Set if the object is a directory }
1469 kFSNodeIsDirectoryMask = $0010;
1470 kFSNodeCopyProtectBit = 6;
1471 kFSNodeCopyProtectMask = $0040;
1472 kFSNodeForkOpenBit = 7; { Set if the file or directory has any open fork }
1473 kFSNodeForkOpenMask = $0080;
1474 kFSNodeHardLinkBit = 8; { Set if the file or directory has a link count > 1 }
1475 kFSNodeHardLinkMask = $00000100;
1476
1477 { Constants for sharingFlags field of FSCatalogInfo }
1478 const
1479 kFSNodeInSharedBit = 2; { Set if a directory is within a share point }
1480 kFSNodeInSharedMask = $0004;
1481 kFSNodeIsMountedBit = 3; { Set if a directory is a share point currently mounted by some user }
1482 kFSNodeIsMountedMask = $0008;
1483 kFSNodeIsSharePointBit = 5; { Set if a directory is a share point (exported volume) }
1484 kFSNodeIsSharePointMask = $0020;
1485
1486 {$ifc TARGET_CPU_64}
1487 {
1488 * FSCatalogInfo
1489 *
1490 * Discussion:
1491 * For each of the items in this structure, if the given bit is set
1492 * in the whichInfo paramater to the FSGetCatalogInfo call then the
1493 * field will be filled in on return. Some fields which are not
1494 * asked for my be returned as well, but do not depend on this
1495 * behaviour.
1496 }
1497 type
1498 FSCatalogInfoPtr = ^FSCatalogInfo;
1499 FSCatalogInfo = record
1500 {
1501 * kFSCatInfoNodeFlags / flag bits set if the file is locked, open,
1502 * is a directory, etc.
1503 }
1504 nodeFlags: UInt16; { node flags }
1505
1506 {
1507 * kFSCatInfoVolume / the volume reference of the returned item
1508 }
1509 volume: FSVolumeRefNum; { object's volume ref }
1510
1511 {
1512 * kFSCatInfoParentDirID / the directory id of the parent of the
1513 * returned item
1514 }
1515 parentDirID: UInt32; { parent directory's ID }
1516
1517 {
1518 * kFSCatInfoNodeID / the file id of the returned item
1519 }
1520 nodeID: UInt32; { file/directory ID }
1521
1522 {
1523 * kFSCatInfoSharingFlags / kioFlAttribMountedBit,
1524 * kioFlAttribSharePointBit
1525 }
1526 sharingFlags: UInt8; { kioFlAttribMountedBit and kioFlAttribSharePointBit }
1527 userPrivileges: UInt8; { user's effective AFP privileges (same as ioACUser) }
1528 reserved1: UInt8;
1529
1530 {
1531 * Unused
1532 }
1533 reserved2: UInt8;
1534
1535 {
1536 * kFSCatInfoCreateDate / date and time of creation
1537 }
1538 createDate: UTCDateTime; { date and time of creation }
1539
1540 {
1541 * kFSCatInfoContentMod / date and time of last modification of the
1542 * content of the returned item
1543 }
1544 contentModDate: UTCDateTime; { date and time of last fork modification }
1545
1546 {
1547 * kFSCatInfoAttrMod / date and time of the last modification of the
1548 * attributes of the returned item
1549 }
1550 attributeModDate: UTCDateTime; { date and time of last attribute modification }
1551
1552 {
1553 * kFSCatInfoAccessDate / date and time of the last access to the
1554 * returned item
1555 }
1556 accessDate: UTCDateTime; { date and time of last access (for Mac OS X) }
1557
1558 {
1559 * kFSCatInfoBackupDate / date and time of the last backup for the
1560 * returned item
1561 }
1562 backupDate: UTCDateTime; { date and time of last backup }
1563
1564 {
1565 * kFSCatInfoPermissions / Mac OS X only, file system permissions of
1566 * the returned item. Coerce to a FSPermissionInfo to use.
1567 }
1568 permissions: FSPermissionInfo; { permissions (for Mac OS X), as FSPermissionInfo }
1569
1570 {
1571 * kFSCatInfoFinderInfo / file type, creator, flags, location.
1572 * Coerce to a File/FolderInfo to use.
1573 }
1574 finderInfo: packed array [0..15] of UInt8; { Finder information part 1, as FileInfo or FolderInfo }
1575
1576 {
1577 * kFSCatInfoFinderXInfo / icon, script, et al. Coerce to a
1578 * ExtendedFile/FolderInfo to use.
1579 }
1580 extFinderInfo: packed array [0..15] of UInt8; { Finder information part 2, as ExtendedFileInfo or ExtendedFolderInfo }
1581
1582
1583 {
1584 * kFSCatInfoDataSizes / the logical size of the data fork of the
1585 * returned item if a file
1586 }
1587 dataLogicalSize: UInt64; { files only }
1588
1589 {
1590 * kFSCatInfoDataSizes / the physical size of the data fork of the
1591 * returned item if a file
1592 }
1593 dataPhysicalSize: UInt64; { files only }
1594
1595 {
1596 * kFSCatInfoRsrcSizes / the logical size of the resource fork of the
1597 * returned item if a file
1598 }
1599 rsrcLogicalSize: UInt64; { files only }
1600
1601 {
1602 * kFSCatInfoRsrcSizes / the physical size of the resource fork of
1603 * the returned item if a file
1604 }
1605 rsrcPhysicalSize: UInt64; { files only }
1606
1607
1608 {
1609 * kFSCatInfoValence / folders only, zero for files.
1610 }
1611 valence: UInt32; { folders only }
1612
1613 {
1614 * kFSCatInfoTextEncoding / the text encoding hint for the returned
1615 * item
1616 }
1617 textEncodingHint: TextEncoding;
1618 end;
1619 {$elsec}
1620 type
1621 FSCatalogInfoPtr = ^FSCatalogInfo;
1622 FSCatalogInfo = record
1623 nodeFlags: UInt16; { node flags }
1624 volume: FSVolumeRefNum; { object's volume ref }
1625 parentDirID: UInt32; { parent directory's ID }
1626 nodeID: UInt32; { file/directory ID }
1627 sharingFlags: UInt8; { kioFlAttribMountedBit and kioFlAttribSharePointBit }
1628 userPrivileges: UInt8; { user's effective AFP privileges (same as ioACUser) }
1629 reserved1: UInt8;
1630 reserved2: UInt8;
1631 createDate: UTCDateTime; { date and time of creation }
1632 contentModDate: UTCDateTime; { date and time of last fork modification }
1633 attributeModDate: UTCDateTime; { date and time of last attribute modification }
1634 accessDate: UTCDateTime; { date and time of last access (for Mac OS X) }
1635 backupDate: UTCDateTime; { date and time of last backup }
1636 permissions: array [0..3] of UInt32; { permissions (for Mac OS X) }
1637 finderInfo: packed array [0..15] of UInt8; { Finder information part 1 }
1638 extFinderInfo: packed array [0..15] of UInt8; { Finder information part 2 }
1639
1640 dataLogicalSize: UInt64; { files only }
1641 dataPhysicalSize: UInt64; { files only }
1642 rsrcLogicalSize: UInt64; { files only }
1643 rsrcPhysicalSize: UInt64; { files only }
1644
1645 valence: UInt32; { folders only }
1646 textEncodingHint: TextEncoding;
1647 end;
1648 {$endc} {TARGET_CPU_64}
1649
1650 type
1651 FSRefParam = record
1652 qLink: QElemPtr; {queue link in header}
1653 qType: SInt16; {type byte for safety check}
1654 ioTrap: SInt16; {FS: the Trap}
1655 ioCmdAddr: Ptr; {FS: address to dispatch to}
1656 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1657 ioResult: {volatile} OSErr; {result code}
1658 ioNamePtr: ConstStringPtr; {ptr to Vol:FileName string}
1659 ioVRefNum: FSVolumeRefNum; {volume refnum (DrvNum for Eject and MountVol)}
1660
1661 reserved1: SInt16; { was ioRefNum }
1662 reserved2: UInt8; { was ioVersNum }
1663 reserved3: UInt8; { was ioPermssn }
1664
1665 ref: {const} FSRefPtr; { Input ref; the target of the call }
1666 whichInfo: FSCatalogInfoBitmap;
1667 catInfo: FSCatalogInfoPtr;
1668 nameLength: UniCharCount; { input name length for create/rename }
1669 name: {const} UniCharPtr; { input name for create/rename }
1670 ioDirID: UInt32;
1671 spec: FSSpecPtr;
1672 parentRef: FSRefPtr; { ref of directory to move another ref to }
1673 newRef: FSRefPtr; { Output ref }
1674 textEncodingHint: TextEncoding; { for Rename, MakeFSRefUnicode }
1675 outName: HFSUniStr255Ptr; { Output name for GetCatalogInfo }
1676 end;
1677 FSRefParamPtr = ^FSRefParam;
1678 { for use with PBCreateFileAndOpenFork}
1679 type
1680 FSRefForkIOParam = record
1681 qLink: QElemPtr; {queue link in header}
1682 qType: SInt16; {type byte for safety check}
1683 ioTrap: SInt16; {FS: the Trap}
1684 ioCmdAddr: Ptr; {FS: address to dispatch to}
1685 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1686 ioResult: {volatile} OSErr; {result code}
1687 parentRef: {const} FSRefPtr; { ref of directory to move another ref to }
1688 nameLength: UniCharCount; { input name length for create/rename }
1689 name: {const} UniCharPtr; { input name for create/rename }
1690 whichInfo: FSCatalogInfoBitmap;
1691 catInfo: {const} FSCatalogInfoPtr;
1692 forkNameLength: UniCharCount; { input; length of fork name }
1693 forkName: {const} UniCharPtr; { input; name of fork (NULL indicates data fork) }
1694 permissions: SInt8; { desired access to the fork }
1695 reserved1: UInt8;
1696 forkRefNum: FSIORefNum; { Output refNum of newly opened fork }
1697 newRef: FSRefPtr; { Output ref }
1698 end;
1699 FSRefForkIOParamPtr = ^FSRefForkIOParam;
1700 type
1701 FSIterator = ^OpaqueFSIterator; { an opaque type }
1702 OpaqueFSIterator = record end;
1703 FSIteratorPtr = ^FSIterator; { when a var xx:FSIterator parameter can be nil, it is changed to xx: FSIteratorPtr }
1704 const
1705 kFSIterateFlat = 0; { Immediate children of container only }
1706 kFSIterateSubtree = 1; { Entire subtree rooted at container }
1707 kFSIterateDelete = 2;
1708 kFSIterateReserved = -4; { SInt32($FFFFFFFC) }
1709
1710 type
1711 FSIteratorFlags = OptionBits;
1712 FSSearchParams = record
1713 searchTime: Duration; { a Time Manager duration }
1714 searchBits: OptionBits; { which fields to search on }
1715 searchNameLength: UniCharCount;
1716 searchName: {const} UniCharPtr;
1717 searchInfo1: FSCatalogInfoPtr; { values and lower bounds }
1718 searchInfo2: FSCatalogInfoPtr; { masks and upper bounds }
1719 end;
1720 FSSearchParamsPtr = ^FSSearchParams;
1721 type
1722 FSCatalogBulkParam = record
1723 qLink: QElemPtr; {queue link in header}
1724 qType: SInt16; {type byte for safety check}
1725 ioTrap: SInt16; {FS: the Trap}
1726 ioCmdAddr: Ptr; {FS: address to dispatch to}
1727 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1728 ioResult: {volatile} OSErr; {result code}
1729 containerChanged: Boolean; { true if container changed since last iteration }
1730 reserved: UInt8; { make following fields 4-byte aligned }
1731
1732 iteratorFlags: FSIteratorFlags;
1733 iterator: FSIterator;
1734 container: {const} FSRefPtr; { directory/volume to iterate }
1735 maximumItems: ItemCount;
1736 actualItems: ItemCount;
1737 whichInfo: FSCatalogInfoBitmap;
1738 catalogInfo: FSCatalogInfoPtr; { returns an array }
1739 refs: FSRefPtr; { returns an array }
1740 specs: FSSpecPtr; { returns an array }
1741 names: HFSUniStr255Ptr; { returns an array }
1742 searchParams: {const} FSSearchParamsPtr;
1743 end;
1744 FSCatalogBulkParamPtr = ^FSCatalogBulkParam;
1745 type
1746 FSAllocationFlags = UInt16;
1747 const
1748 kFSAllocDefaultFlags = $0000; { as much as possible, not contiguous }
1749 kFSAllocAllOrNothingMask = $0001; { allocate all of the space, or nothing }
1750 kFSAllocContiguousMask = $0002; { new space must be one contiguous piece }
1751 kFSAllocNoRoundUpMask = $0004; { don't round up allocation to clump size }
1752 kFSAllocReservedMask = $FFF8; { these bits are reserved and must not be set }
1753
1754 type
1755 FSForkIOParam = record
1756 qLink: QElemPtr; {queue link in header}
1757 qType: SInt16; {type byte for safety check}
1758 ioTrap: SInt16; {FS: the Trap}
1759 ioCmdAddr: Ptr; {FS: address to dispatch to}
1760 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1761 ioResult: {volatile} OSErr; {result code}
1762 reserved1: UnivPtr; { was ioNamePtr }
1763 reserved2: SInt16; { was ioVRefNum }
1764 forkRefNum: FSIORefNum; { same as ioRefNum }
1765 reserved3: UInt8; { was ioVersNum }
1766 permissions: SInt8; { desired access to the fork }
1767 ref: {const} FSRefPtr; { which object to open }
1768
1769
1770 buffer: Ptr; {data buffer Ptr}
1771 requestCount: UInt32; {requested byte count}
1772 actualCount: UInt32; {actual byte count completed}
1773 positionMode: UInt16; {initial file positioning}
1774 positionOffset: SInt64; {file position offset}
1775
1776 allocationFlags: FSAllocationFlags;
1777 allocationAmount: UInt64;
1778
1779 forkNameLength: UniCharCount; { input; length of fork name }
1780 forkName: {const} UniCharPtr; { input; name of fork }
1781
1782 forkIterator: CatPositionRec;
1783 outForkName: HFSUniStr255Ptr; { output; name of fork }
1784 end;
1785 FSForkIOParamPtr = ^FSForkIOParam;
1786 type
1787 FSForkInfoFlags = UInt8;
1788 FSForkInfo = record
1789 flags: FSForkInfoFlags; { copy of FCB flags }
1790 permissions: SInt8;
1791 volume: FSVolumeRefNum;
1792 reserved2: UInt32;
1793 nodeID: UInt32; { file or directory ID }
1794 forkID: UInt32; { fork ID }
1795 currentPosition: UInt64;
1796 logicalEOF: UInt64;
1797 physicalEOF: UInt64;
1798 process: UInt64; { should be ProcessSerialNumber }
1799 end;
1800 FSForkInfoPtr = ^FSForkInfo;
1801 type
1802 FSForkCBInfoParam = record
1803 qLink: QElemPtr; {queue link in header}
1804 qType: SInt16; {type byte for safety check}
1805 ioTrap: SInt16; {FS: the Trap}
1806 ioCmdAddr: Ptr; {FS: address to dispatch to}
1807 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1808 ioResult: {volatile} OSErr; {result code}
1809 desiredRefNum: FSIORefNum; { 0 to iterate, non-0 for specific refnum }
1810 volumeRefNum: FSVolumeRefNum; { volume to match, or 0 for all volumes }
1811 iterator: FSIORefNum; { 0 to start iteration }
1812 actualRefNum: FSVolumeRefNum; { actual refnum found }
1813
1814 ref: FSRefPtr;
1815 forkInfo: FSForkInfoPtr;
1816 forkName: HFSUniStr255Ptr;
1817 end;
1818 FSForkCBInfoParamPtr = ^FSForkCBInfoParam;
1819 { Parameter block for use with 64 bit range lock calls.}
1820 type
1821 FSRangeLockParam = record
1822 qLink: QElemPtr; {queue link in header}
1823 qType: SInt16; {type byte for safety check}
1824 ioTrap: SInt16; {FS: the Trap}
1825 ioCmdAddr: Ptr; {FS: address to dispatch to}
1826 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1827 ioResult: {volatile} OSErr; {result code}
1828 forkRefNum: FSIORefNum; { fork to operate on }
1829 requestCount: UInt64; {requested byte count}
1830 positionMode: UInt16; {initial file positioning}
1831 positionOffset: SInt64; {file position offset}
1832 rangeStart: UInt64; { byte number of first byte (un)locked }
1833 end;
1834 FSRangeLockParamPtr = ^FSRangeLockParam;
1835 type
1836 FSVolumeInfoBitmap = UInt32;
1837 const
1838 kFSVolInfoNone = $0000;
1839 kFSVolInfoCreateDate = $0001;
1840 kFSVolInfoModDate = $0002;
1841 kFSVolInfoBackupDate = $0004;
1842 kFSVolInfoCheckedDate = $0008;
1843 kFSVolInfoFileCount = $0010;
1844 kFSVolInfoDirCount = $0020;
1845 kFSVolInfoSizes = $0040; { totalBytes and freeBytes }
1846 kFSVolInfoBlocks = $0080; { blockSize, totalBlocks, freeBlocks }
1847 kFSVolInfoNextAlloc = $0100;
1848 kFSVolInfoRsrcClump = $0200;
1849 kFSVolInfoDataClump = $0400;
1850 kFSVolInfoNextID = $0800;
1851 kFSVolInfoFinderInfo = $1000;
1852 kFSVolInfoFlags = $2000;
1853 kFSVolInfoFSInfo = $4000; { filesystemID, signature }
1854 kFSVolInfoDriveInfo = $8000; { driveNumber, driverRefNum }
1855 kFSVolInfoGettableInfo = $FFFF; { This seems like it is here just for completeness }
1856 kFSVolInfoSettableInfo = $3004; { backup date, Finder info, flags }
1857
1858 { FSVolumeInfo.flags bits. These are the same as for ioVAtrb, but with nicer names. }
1859 const
1860 kFSVolFlagDefaultVolumeBit = 5; { Set if the volume is the default volume }
1861 kFSVolFlagDefaultVolumeMask = $0020;
1862 kFSVolFlagFilesOpenBit = 6; { Set if there are open files or iterators }
1863 kFSVolFlagFilesOpenMask = $0040;
1864 kFSVolFlagHardwareLockedBit = 7; { Set if volume is locked by a hardware setting }
1865 kFSVolFlagHardwareLockedMask = $0080;
1866 kFSVolFlagJournalingActiveBit = 14; { Set if journaling is active on volume }
1867 kFSVolFlagJournalingActiveMask = $4000;
1868 kFSVolFlagSoftwareLockedBit = 15; { Set if volume is locked by software }
1869 kFSVolFlagSoftwareLockedMask = $8000;
1870
1871
1872 type
1873 FSVolumeInfo = record
1874 { Dates -- zero means "never" or "unknown" }
1875 createDate: UTCDateTime;
1876 modifyDate: UTCDateTime;
1877 backupDate: UTCDateTime;
1878 checkedDate: UTCDateTime;
1879
1880 { File/Folder counts -- return zero if unknown }
1881 fileCount: UInt32; { total files on volume }
1882 folderCount: UInt32; { total folders on volume }
1883 { Note: no root directory counts }
1884
1885 totalBytes: UInt64; { total number of bytes on volume }
1886 freeBytes: UInt64; { number of free bytes on volume }
1887
1888 { HFS and HFS Plus specific. Set fields to zero if not appropriate }
1889 blockSize: UInt32; { size (in bytes) of allocation blocks }
1890 totalBlocks: UInt32; { number of allocation blocks in volume }
1891 freeBlocks: UInt32; { number of unused allocation blocks }
1892 nextAllocation: UInt32; { start of next allocation search }
1893 rsrcClumpSize: UInt32; { default resource fork clump size }
1894 dataClumpSize: UInt32; { default data fork clump size }
1895 nextCatalogID: UInt32; { next unused catalog node ID ��� OYG ��� need to make HFSVolumes.h work Should be HFSCatalogNodeID}
1896 finderInfo: packed array [0..31] of UInt8; { information used by Finder }
1897
1898 { Identifying information }
1899 flags: UInt16; { ioVAtrb }
1900 filesystemID: UInt16; { ioVFSID }
1901 signature: UInt16; { ioVSigWord, unique within an FSID }
1902 driveNumber: UInt16; { ioVDrvInfo }
1903 driverRefNum: FSIORefNum; { ioVDRefNum }
1904 end;
1905 FSVolumeInfoPtr = ^FSVolumeInfo;
1906 type
1907 FSVolumeInfoParam = record
1908 qLink: QElemPtr; {queue link in header}
1909 qType: SInt16; {type byte for safety check}
1910 ioTrap: SInt16; {FS: the Trap}
1911 ioCmdAddr: Ptr; {FS: address to dispatch to}
1912 ioCompletion: IOCompletionUPP; {completion routine addr (0 for synch calls)}
1913 ioResult: {volatile} OSErr; {result code}
1914 ioNamePtr: StringPtr; { unused }
1915 ioVRefNum: FSVolumeRefNum; { volume refnum }
1916
1917 volumeIndex: UInt32; { index, or 0 to use ioVRefNum }
1918 whichInfo: FSVolumeInfoBitmap; { which volumeInfo fields to get/set }
1919 volumeInfo: FSVolumeInfoPtr; { information about the volume }
1920 volumeName: HFSUniStr255Ptr; { output; pointer to volume name }
1921 ref: FSRefPtr; { volume's FSRef }
1922 end;
1923 FSVolumeInfoParamPtr = ^FSVolumeInfoParam;
1924 type
1925 GetVolParmsInfoBuffer = record
1926 vMVersion: SInt16; {version number}
1927 vMAttrib: SInt32; {bit vector of attributes (see vMAttrib constants)}
1928 vMLocalHand: Handle; {handle to private data}
1929 vMServerAdr: SInt32; {AppleTalk server address or zero}
1930 { vMVersion 1 GetVolParmsInfoBuffer ends here }
1931 vMVolumeGrade: SInt32; {approx. speed rating or zero if unrated}
1932 vMForeignPrivID: SInt16; {foreign privilege model supported or zero if none}
1933 { vMVersion 2 GetVolParmsInfoBuffer ends here }
1934 vMExtendedAttributes: SInt32; {extended attribute bits (see vMExtendedAttributes constants)}
1935 { vMVersion 3 GetVolParmsInfoBuffer ends here }
1936 vMDeviceID: UnivPtr; { device id name for interoperability with IOKit }
1937 { vMVersion 4 GetVolParmsInfoBuffer ends here }
1938 vMMaxNameLength: UniCharCount;
1939 { vMVersion 5 GetVolParmsInfoBuffer ends here }
1940 end;
1941 {
1942 The following are structures to be filled out with the _PBGetVolMountInfo call
1943 and passed back into the _PBVolumeMount call for external file system mounts.
1944 }
1945 { the "signature" of the file system }
1946
1947 type
1948 VolumeType = OSType;
1949 const
1950 { the signature for AppleShare }
1951 AppleShareMediaType = FourCharCode('afpm');
1952
1953 {
1954 VolMount stuff was once in FSM.�
1955 }
1956 type
1957 VolMountInfoHeader = record
1958 length: SInt16; { length of location data (including self) }
1959 media: VolumeType; { type of media. Variable length data follows }
1960 end;
1961 type
1962 VolMountInfoPtr = ^VolMountInfoHeader;
1963 { The new volume mount info record. The old one is included for compatibility.
1964 the new record allows access by foriegn filesystems writers to the flags
1965 portion of the record. This portion is now public.
1966 }
1967 type
1968 VolumeMountInfoHeader = record
1969 length: SInt16; { length of location data (including self) }
1970 media: VolumeType; { type of media (must be registered with Apple) }
1971 flags: SInt16; { volume mount flags. Variable length data follows }
1972 end;
1973 VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
1974 { volume mount flags }
1975 const
1976 volMountNoLoginMsgFlagBit = 0; { Input to VolumeMount: If set, the file system }
1977 volMountNoLoginMsgFlagMask = $0001; { should suppresss any log-in message/greeting dialog }
1978 volMountExtendedFlagsBit = 7; { Input to VolumeMount: If set, the mount info is a }
1979 volMountExtendedFlagsMask = $0080; { AFPXVolMountInfo record for 3.7 AppleShare Client }
1980 volMountInteractBit = 15; { Input to VolumeMount: If set, it's OK for the file system }
1981 volMountInteractMask = $8000; { to perform user interaction to mount the volume }
1982 volMountChangedBit = 14; { Output from VoumeMount: If set, the volume was mounted, but }
1983 volMountChangedMask = $4000; { the volume mounting information record needs to be updated. }
1984 volMountFSReservedMask = $00FF; { bits 0-7 are defined by each file system for its own use }
1985 volMountSysReservedMask = $FF00; { bits 8-15 are reserved for Apple system use }
1986
1987
1988 type
1989 AFPVolMountInfo = record
1990 length: SInt16; { length of location data (including self) }
1991 media: VolumeType; { type of media }
1992 flags: SInt16; { bits for no messages, no reconnect }
1993 nbpInterval: SInt8; { NBP Interval parameter (IM2, p.322) }
1994 nbpCount: SInt8; { NBP Interval parameter (IM2, p.322) }
1995 uamType: SInt16; { User Authentication Method }
1996 zoneNameOffset: SInt16; { short positive offset from start of struct to Zone Name }
1997 serverNameOffset: SInt16; { offset to pascal Server Name string }
1998 volNameOffset: SInt16; { offset to pascal Volume Name string }
1999 userNameOffset: SInt16; { offset to pascal User Name string }
2000 userPasswordOffset: SInt16; { offset to pascal User Password string }
2001 volPasswordOffset: SInt16; { offset to pascal Volume Password string }
2002 AFPData: packed array [1..144] of char; { variable length data may follow }
2003 end;
2004 AFPVolMountInfoPtr = ^AFPVolMountInfo;
2005
2006
2007 { AFPXVolMountInfo is the new AFP volume mount info record, requires the 3.7 AppleShare Client }
2008 type
2009 AFPXVolMountInfo = record
2010 length: SInt16; { length of location data (including self) }
2011 media: VolumeType; { type of media }
2012 flags: SInt16; { bits for no messages, no reconnect }
2013 nbpInterval: SInt8; { NBP Interval parameter (IM2, p.322) }
2014 nbpCount: SInt8; { NBP Interval parameter (IM2, p.322) }
2015 uamType: SInt16; { User Authentication Method type }
2016 zoneNameOffset: SInt16; { short positive offset from start of struct to Zone Name }
2017 serverNameOffset: SInt16; { offset to pascal Server Name string }
2018 volNameOffset: SInt16; { offset to pascal Volume Name string }
2019 userNameOffset: SInt16; { offset to pascal User Name string }
2020 userPasswordOffset: SInt16; { offset to pascal User Password string }
2021 volPasswordOffset: SInt16; { offset to pascal Volume Password string }
2022 extendedFlags: SInt16; { extended flags word }
2023 uamNameOffset: SInt16; { offset to a pascal UAM name string }
2024 alternateAddressOffset: SInt16; { offset to Alternate Addresses in tagged format }
2025 AFPData: packed array [1..176] of char; { variable length data may follow }
2026 end;
2027 AFPXVolMountInfoPtr = ^AFPXVolMountInfo;
2028 const
2029 kAFPExtendedFlagsAlternateAddressMask = 1; { bit in AFPXVolMountInfo.extendedFlags that means alternateAddressOffset is used}
2030
2031
2032 const
2033 { constants for use in AFPTagData.fType field}
2034 kAFPTagTypeIP = $01; { 4 byte IP address (MSB first) }
2035 kAFPTagTypeIPPort = $02; { 4 byte IP address, 2 byte port (MSB first) }
2036 kAFPTagTypeDDP = $03; { Net,Node,Socket Sent by the server, currently unused by the client }
2037 kAFPTagTypeDNS = $04; { DNS name in address:port format (total length variable up to 254 chars of dns name) }
2038
2039
2040 const
2041 { constants for use in AFPTagData.fLength field}
2042 kAFPTagLengthIP = $06;
2043 kAFPTagLengthIPPort = $08;
2044 kAFPTagLengthDDP = $06;
2045
2046 type
2047 AFPTagData = packed record
2048 fLength: UInt8; { length of this data tag including the fLength field }
2049 fType: UInt8;
2050 fData: packed array [0..0] of UInt8; { variable length data }
2051 end;
2052 type
2053 AFPAlternateAddressPtr = ^AFPAlternateAddress;
2054 AFPAlternateAddress = packed record
2055 { ����NOTE: fVersion was missing in 3.2 Universal Interfaces}
2056 fVersion: UInt8; { version of the structure (currently 0x00)}
2057 fAddressCount: UInt8;
2058 fAddressList: packed array [0..0] of UInt8; { actually variable length packed set of AFPTagData }
2059 end;
2060 const
2061 kLargeIconSize = 256;
2062 kLarge4BitIconSize = 512;
2063 kLarge8BitIconSize = 1024;
2064 kSmallIconSize = 64;
2065 kSmall4BitIconSize = 128;
2066 kSmall8BitIconSize = 256;
2067
2068 {
2069 * NewIOCompletionUPP()
2070 *
2071 * Availability:
2072 * Mac OS X: in version 10.0 and later in CoreServices.framework
2073 * CarbonLib: in CarbonLib 1.0 and later
2074 * Non-Carbon CFM: available as macro/inline
2075 }
2076 { old name was NewIOCompletionProc }
NewIOCompletionUPPnull2077 function NewIOCompletionUPP( userRoutine: IOCompletionProcPtr ): IOCompletionUPP; external name '_NewIOCompletionUPP';
2078 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2079
2080 {
2081 * DisposeIOCompletionUPP()
2082 *
2083 * Availability:
2084 * Mac OS X: in version 10.0 and later in CoreServices.framework
2085 * CarbonLib: in CarbonLib 1.0 and later
2086 * Non-Carbon CFM: available as macro/inline
2087 }
2088 procedure DisposeIOCompletionUPP( userUPP: IOCompletionUPP ); external name '_DisposeIOCompletionUPP';
2089 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2090
2091 {
2092 * InvokeIOCompletionUPP()
2093 *
2094 * Availability:
2095 * Mac OS X: in version 10.0 and later in CoreServices.framework
2096 * CarbonLib: in CarbonLib 1.0 and later
2097 * Non-Carbon CFM: available as macro/inline
2098 }
2099 { old name was CallIOCompletionProc }
2100 procedure InvokeIOCompletionUPP( paramBlock: ParmBlkPtr; userUPP: IOCompletionUPP ); external name '_InvokeIOCompletionUPP';
2101 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2102
2103 {#if __MACH__
2104 #define NewIOCompletionUPP(userRoutine) ((IOCompletionUPP)userRoutine)
2105 #define DisposeIOCompletionUPP(userUPP)
2106 #define InvokeIOCompletionUPP(paramBlock, userUPP) (*userUPP)(paramBlock)
2107 #endif}
2108
2109 {
2110 MakeFSRefUnicode
2111 Create an FSRef for an existing object specified by
2112 Parent FSRef and Unicode name.
2113 -> ioCompletion A pointer to a completion routine
2114 <- ioResult The result code of the function
2115 -> ref A pointer to the parent directory FSRef
2116 -> name A pointer to Unicode name
2117 -> nameLength The length of the Unicode Name
2118 -> textEncodingHint A suggested text encoding to use for the name
2119 <- newRef A pointer to an FSRef
2120 }
2121 {
2122 * FSMakeFSRefUnicode()
2123 *
2124 * Mac OS X threading:
2125 * Thread safe since version 10.0
2126 *
2127 * Availability:
2128 * Mac OS X: in version 10.0 and later in CoreServices.framework
2129 * CarbonLib: in CarbonLib 1.0 and later
2130 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2131 }
FSMakeFSRefUnicodenull2132 function FSMakeFSRefUnicode( const (*var*) parentRef: FSRef; nameLength: UniCharCount; name: UniCharPtr; textEncodingHint: TextEncoding; var newRef: FSRef ): OSErr; external name '_FSMakeFSRefUnicode';
2133 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2134 {
2135 * PBMakeFSRefUnicodeSync()
2136 *
2137 * Mac OS X threading:
2138 * Thread safe since version 10.0
2139 *
2140 * Availability:
2141 * Mac OS X: in version 10.0 and later in CoreServices.framework
2142 * CarbonLib: in CarbonLib 1.0 and later
2143 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2144 }
2145 function PBMakeFSRefUnicodeSync( var paramBlock: FSRefParam ): OSErr; external name '_PBMakeFSRefUnicodeSync';
2146 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2147
2148
2149 {
2150 * PBMakeFSRefUnicodeAsync()
2151 *
2152 * Mac OS X threading:
2153 * Thread safe since version 10.0
2154 *
2155 * Availability:
2156 * Mac OS X: in version 10.0 and later in CoreServices.framework
2157 * CarbonLib: in CarbonLib 1.0 and later
2158 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2159 }
2160 procedure PBMakeFSRefUnicodeAsync( var paramBlock: FSRefParam ); external name '_PBMakeFSRefUnicodeAsync';
2161 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2162
2163
2164 {
2165 CompareFSRefs
2166 Test whether two FSRefs refer to the same file or directory.
2167 If they do, noErr is returned. Otherwise, an appropriate error
2168 (such as errFSRefsDifferent) is returned.
2169 -> ioCompletion A pointer to a completion routine
2170 <- ioResult The result code of the function
2171 -> ref A pointer to the first FSRef
2172 -> parentRef A pointer to the second FSRef
2173 }
2174 {
2175 * FSCompareFSRefs()
2176 *
2177 * Mac OS X threading:
2178 * Thread safe since version 10.0
2179 *
2180 * Availability:
2181 * Mac OS X: in version 10.0 and later in CoreServices.framework
2182 * CarbonLib: in CarbonLib 1.0 and later
2183 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2184 }
FSCompareFSRefsnull2185 function FSCompareFSRefs( const (*var*) ref1: FSRef; const (*var*) ref2: FSRef ): OSErr; external name '_FSCompareFSRefs';
2186 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2187
2188
2189 {
2190 * PBCompareFSRefsSync()
2191 *
2192 * Mac OS X threading:
2193 * Thread safe since version 10.0
2194 *
2195 * Availability:
2196 * Mac OS X: in version 10.0 and later in CoreServices.framework
2197 * CarbonLib: in CarbonLib 1.0 and later
2198 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2199 }
PBCompareFSRefsSyncnull2200 function PBCompareFSRefsSync( var paramBlock: FSRefParam ): OSErr; external name '_PBCompareFSRefsSync';
2201 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2202
2203
2204 {
2205 * PBCompareFSRefsAsync()
2206 *
2207 * Mac OS X threading:
2208 * Thread safe since version 10.0
2209 *
2210 * Availability:
2211 * Mac OS X: in version 10.0 and later in CoreServices.framework
2212 * CarbonLib: in CarbonLib 1.0 and later
2213 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2214 }
2215 procedure PBCompareFSRefsAsync( var paramBlock: FSRefParam ); external name '_PBCompareFSRefsAsync';
2216 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2217
2218
2219 {
2220 CreateFileUnicode
2221 Creates a new file. The input filename is in Unicode.
2222 You can optionally set catalog info for the file.
2223 -> ioCompletion A pointer to a completion routine
2224 <- ioResult The result code of the function
2225 -> ref The directory where the file is to be created
2226 -> whichInfo Which catalog info fields to set
2227 -> catInfo The values for catalog info fields to set; may be NULL
2228 -> nameLength Number of Unicode characters in the file's name
2229 -> name A pointer to the Unicode name
2230 <- spec A pointer to the FSSpec for the new directory; may be NULL. Ignored on 64 bit.
2231 <- newRef A pointer to the FSRef for the new file; may be NULL
2232 }
2233 {
2234 * FSCreateFileUnicode()
2235 *
2236 * Mac OS X threading:
2237 * Thread safe since version 10.0
2238 *
2239 * Availability:
2240 * Mac OS X: in version 10.0 and later in CoreServices.framework
2241 * CarbonLib: in CarbonLib 1.0 and later
2242 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2243 }
FSCreateFileUnicodenull2244 function FSCreateFileUnicode( const (*var*) parentRef: FSRef; nameLength: UniCharCount; name: UniCharPtr; whichInfo: FSCatalogInfoBitmap; catalogInfo: {Const}FSCatalogInfoPtr; newRef: FSRefPtr; newSpec: FSSpecPtr ): OSErr; external name '_FSCreateFileUnicode';
2245 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2246
2247
2248 {
2249 * PBCreateFileUnicodeSync()
2250 *
2251 * Mac OS X threading:
2252 * Thread safe since version 10.0
2253 *
2254 * Availability:
2255 * Mac OS X: in version 10.0 and later in CoreServices.framework
2256 * CarbonLib: in CarbonLib 1.0 and later
2257 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2258 }
PBCreateFileUnicodeSyncnull2259 function PBCreateFileUnicodeSync( var paramBlock: FSRefParam ): OSErr; external name '_PBCreateFileUnicodeSync';
2260 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2261
2262
2263 {
2264 * PBCreateFileUnicodeAsync()
2265 *
2266 * Mac OS X threading:
2267 * Thread safe since version 10.0
2268 *
2269 * Availability:
2270 * Mac OS X: in version 10.0 and later in CoreServices.framework
2271 * CarbonLib: in CarbonLib 1.0 and later
2272 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2273 }
2274 procedure PBCreateFileUnicodeAsync( var paramBlock: FSRefParam ); external name '_PBCreateFileUnicodeAsync';
2275 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2276
2277
2278 {
2279 CreateDirectoryUnicode
2280 Creates a new directory. The input directory name is in Unicode.
2281 You can optionally set catalog info for the directory.
2282 -> ioCompletion A pointer to a completion routine
2283 <- ioResult The result code of the function
2284 -> ref The parent directory where the directory is to be created
2285 -> whichInfo Which catalog info fields to set
2286 -> catInfo The values for catalog info fields to set; may be NULL
2287 -> nameLength Number of Unicode characters in the directory's name
2288 -> name A pointer to the Unicode name
2289 <- ioDirID The DirID of the new directory
2290 <- newSpec A pointer to the FSSpec for the new directory; may be NULL. Ignored on 64 bit.
2291 <- newRef A pointer to the FSRef for the new directory; may be NULL
2292 }
2293 {
2294 * FSCreateDirectoryUnicode()
2295 *
2296 * Mac OS X threading:
2297 * Thread safe since version 10.0
2298 *
2299 * Availability:
2300 * Mac OS X: in version 10.0 and later in CoreServices.framework
2301 * CarbonLib: in CarbonLib 1.0 and later
2302 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2303 }
FSCreateDirectoryUnicodenull2304 function FSCreateDirectoryUnicode( const (*var*) parentRef: FSRef; nameLength: UniCharCount; name: UniCharPtr; whichInfo: FSCatalogInfoBitmap; catalogInfo: {Const}FSCatalogInfoPtr; newRef: FSRefPtr; newSpec: FSSpecPtr; newDirID: UInt32Ptr ): OSErr; external name '_FSCreateDirectoryUnicode';
2305 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2306
2307
2308 {
2309 * PBCreateDirectoryUnicodeSync()
2310 *
2311 * Mac OS X threading:
2312 * Thread safe since version 10.0
2313 *
2314 * Availability:
2315 * Mac OS X: in version 10.0 and later in CoreServices.framework
2316 * CarbonLib: in CarbonLib 1.0 and later
2317 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2318 }
PBCreateDirectoryUnicodeSyncnull2319 function PBCreateDirectoryUnicodeSync( var paramBlock: FSRefParam ): OSErr; external name '_PBCreateDirectoryUnicodeSync';
2320 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2321
2322
2323 {
2324 * PBCreateDirectoryUnicodeAsync()
2325 *
2326 * Mac OS X threading:
2327 * Thread safe since version 10.0
2328 *
2329 * Availability:
2330 * Mac OS X: in version 10.0 and later in CoreServices.framework
2331 * CarbonLib: in CarbonLib 1.0 and later
2332 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2333 }
2334 procedure PBCreateDirectoryUnicodeAsync( var paramBlock: FSRefParam ); external name '_PBCreateDirectoryUnicodeAsync';
2335 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2336
2337
2338 {
2339 DeleteObject
2340 Deletes an existing file or directory.
2341 -> ioCompletion A pointer to a completion routine
2342 <- ioResult The result code of the function
2343 -> ref The file or directory to be deleted
2344 }
2345 {
2346 * FSDeleteObject()
2347 *
2348 * Mac OS X threading:
2349 * Thread safe since version 10.0
2350 *
2351 * Availability:
2352 * Mac OS X: in version 10.0 and later in CoreServices.framework
2353 * CarbonLib: in CarbonLib 1.0 and later
2354 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2355 }
FSDeleteObjectnull2356 function FSDeleteObject( const (*var*) ref: FSRef ): OSErr; external name '_FSDeleteObject';
2357 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2358
2359
2360 {
2361 * PBDeleteObjectSync()
2362 *
2363 * Mac OS X threading:
2364 * Thread safe since version 10.0
2365 *
2366 * Availability:
2367 * Mac OS X: in version 10.0 and later in CoreServices.framework
2368 * CarbonLib: in CarbonLib 1.0 and later
2369 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2370 }
PBDeleteObjectSyncnull2371 function PBDeleteObjectSync( var paramBlock: FSRefParam ): OSErr; external name '_PBDeleteObjectSync';
2372 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2373
2374
2375 {
2376 * PBDeleteObjectAsync()
2377 *
2378 * Mac OS X threading:
2379 * Thread safe since version 10.0
2380 *
2381 * Availability:
2382 * Mac OS X: in version 10.0 and later in CoreServices.framework
2383 * CarbonLib: in CarbonLib 1.0 and later
2384 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2385 }
2386 procedure PBDeleteObjectAsync( var paramBlock: FSRefParam ); external name '_PBDeleteObjectAsync';
2387 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2388
2389
2390 {
2391 UnlinkObject
2392 Unlinks an existing file or deletes an existing directory. This call will succeed on an open file, unlike
2393 DeleteObject. This call will unlink an archive directory link (where DeleteObject will treat the ADL as a directory).
2394 -> ioCompletion A pointer to a completion routine
2395 <- ioResult The result code of the function
2396 -> ref The file or directory to be deleted
2397 }
2398 {
2399 * FSUnlinkObject()
2400 *
2401 * Mac OS X threading:
2402 * Thread safe since version 10.5
2403 *
2404 * Availability:
2405 * Mac OS X: in version 10.5 and later in CoreServices.framework
2406 * CarbonLib: not available
2407 * Non-Carbon CFM: not available
2408 }
FSUnlinkObjectnull2409 function FSUnlinkObject( const (*var*) ref: FSRef ): OSErr; external name '_FSUnlinkObject';
2410 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2411
2412
2413 {
2414 * PBUnlinkObjectSync()
2415 *
2416 * Mac OS X threading:
2417 * Thread safe since version 10.5
2418 *
2419 * Availability:
2420 * Mac OS X: in version 10.5 and later in CoreServices.framework
2421 * CarbonLib: not available
2422 * Non-Carbon CFM: not available
2423 }
PBUnlinkObjectSyncnull2424 function PBUnlinkObjectSync( var paramBlock: FSRefParam ): OSErr; external name '_PBUnlinkObjectSync';
2425 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2426
2427
2428 {
2429 * PBUnlinkObjectAsync()
2430 *
2431 * Mac OS X threading:
2432 * Thread safe since version 10.5
2433 *
2434 * Availability:
2435 * Mac OS X: in version 10.5 and later in CoreServices.framework
2436 * CarbonLib: not available
2437 * Non-Carbon CFM: not available
2438 }
2439 procedure PBUnlinkObjectAsync( var paramBlock: FSRefParam ); external name '_PBUnlinkObjectAsync';
2440 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2441
2442
2443 {
2444 MoveObject
2445 Move an existing file or directory into a different directory.
2446 -> ioCompletion A pointer to a completion routine
2447 <- ioResult The result code of the function
2448 -> ref The file or directory to be moved
2449 -> parentRef The file or directory will be moved into this directory
2450 <- newRef A new FSRef for the file or directory in its new location;
2451 optional, may be NULL
2452 NOTE: Moving an object may change its FSRef. If you want to continue to
2453 refer to the object, you should pass a non-NULL pointer in newRef and use
2454 that returned FSRef to access the object after the move. The FSRef passed
2455 in "ref" may or may not be usable to access the object after it is moved.
2456 "newRef" may point to the same storage as "parentRef" or "ref".
2457 }
2458 {
2459 * FSMoveObject()
2460 *
2461 * Mac OS X threading:
2462 * Thread safe since version 10.0
2463 *
2464 * Availability:
2465 * Mac OS X: in version 10.0 and later in CoreServices.framework
2466 * CarbonLib: in CarbonLib 1.0 and later
2467 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2468 }
FSMoveObjectnull2469 function FSMoveObject( const (*var*) ref: FSRef; const (*var*) destDirectory: FSRef; newRef: FSRefPtr ): OSErr; external name '_FSMoveObject';
2470 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2471
2472
2473 {
2474 * PBMoveObjectSync()
2475 *
2476 * Mac OS X threading:
2477 * Thread safe since version 10.0
2478 *
2479 * Availability:
2480 * Mac OS X: in version 10.0 and later in CoreServices.framework
2481 * CarbonLib: in CarbonLib 1.0 and later
2482 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2483 }
PBMoveObjectSyncnull2484 function PBMoveObjectSync( var paramBlock: FSRefParam ): OSErr; external name '_PBMoveObjectSync';
2485 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2486
2487
2488 {
2489 * PBMoveObjectAsync()
2490 *
2491 * Mac OS X threading:
2492 * Thread safe since version 10.0
2493 *
2494 * Availability:
2495 * Mac OS X: in version 10.0 and later in CoreServices.framework
2496 * CarbonLib: in CarbonLib 1.0 and later
2497 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2498 }
2499 procedure PBMoveObjectAsync( var paramBlock: FSRefParam ); external name '_PBMoveObjectAsync';
2500 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2501
2502
2503 {
2504 ExchangeObjects
2505 swap the contents of two files.
2506 -> ioCompletion A pointer to a completion routine
2507 <- ioResult The result code of the function
2508 -> ref The first file
2509 -> parentRef The second file
2510 }
2511 {
2512 * FSExchangeObjects()
2513 *
2514 * Mac OS X threading:
2515 * Thread safe since version 10.0
2516 *
2517 * Availability:
2518 * Mac OS X: in version 10.0 and later in CoreServices.framework
2519 * CarbonLib: in CarbonLib 1.0 and later
2520 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2521 }
FSExchangeObjectsnull2522 function FSExchangeObjects( const (*var*) ref: FSRef; const (*var*) destRef: FSRef ): OSErr; external name '_FSExchangeObjects';
2523 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2524
2525
2526 {
2527 * PBExchangeObjectsSync()
2528 *
2529 * Mac OS X threading:
2530 * Thread safe since version 10.0
2531 *
2532 * Availability:
2533 * Mac OS X: in version 10.0 and later in CoreServices.framework
2534 * CarbonLib: in CarbonLib 1.0 and later
2535 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2536 }
PBExchangeObjectsSyncnull2537 function PBExchangeObjectsSync( var paramBlock: FSRefParam ): OSErr; external name '_PBExchangeObjectsSync';
2538 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2539
2540
2541 {
2542 * PBExchangeObjectsAsync()
2543 *
2544 * Mac OS X threading:
2545 * Thread safe since version 10.0
2546 *
2547 * Availability:
2548 * Mac OS X: in version 10.0 and later in CoreServices.framework
2549 * CarbonLib: in CarbonLib 1.0 and later
2550 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2551 }
2552 procedure PBExchangeObjectsAsync( var paramBlock: FSRefParam ); external name '_PBExchangeObjectsAsync';
2553 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2554
2555
2556 {
2557 FSReplaceObject and FSPathReplaceObject
2558
2559 You can use the FSReplaceObject and FSPathReplaceObject functions to replace
2560 one object, the original object, with another, the replacement object.
2561 FSReplaceObject and FSPathReplaceObject are provided to assist in properly
2562 preserving metadata during safe save operations. These functions allow files
2563 to replace files, directories to replace directories, directories to replace
2564 files and files to replace directories (so a package can replace a file, or
2565 a file can replace a package). Both objects must reside on the same volume.
2566
2567 If FSReplaceObject or FSPathReplaceObject are successful, the result object
2568 will exist at the location of the original object. Nothing will exist at the
2569 location of the replacement object. By default FSReplaceObject and FSPathReplaceObject
2570 will test the object for write access, and fail if write access is not available.
2571 Write access in this context is ACL_WRITE_DATA for files and ACL_ADD_FILE for directories.
2572 This check can be bypassed by passing the kFSReplaceObjectDoNotCheckObjectWriteAccess flag.
2573
2574 FSReplaceObject and FSPathReplaceObject may need to create a temporary object
2575 when one of the input objects is a directory, or when the
2576 kFSReplaceObjectSaveOriginalAsABackup option is specified. The temporary object
2577 is required since the rename system call does not handle non-empty directory
2578 replacement or file <-> directory replacement. The file replacing file case
2579 does not use a temporary object (unless the kFSReplaceObjectSaveOriginalAsABackup
2580 option is specified). If no temporary name is provided and a temporary object
2581 is required, then the functions will return an error. Providing a temporary
2582 name will also allow an application to recover the original object should a
2583 catastrophic failure (such as a power outage) occur during a replacement
2584 involving a directory. The temporary object will be created with the temporary
2585 name either in the temporary directory specified by the temporaryDirectory
2586 parameter, or in the preferred temporary directory (the preferred temporary
2587 directory can be obtained with the FSGetTemporaryDirectoryForReplaceObject
2588 or FSPathGetTemporaryDirectoryForReplaceObject functions).
2589
2590 If the kFSReplaceObjectSaveOriginalAsABackup option is specified, the original
2591 object will be saved in one of two locations: If the temporaryName parameter
2592 is provided, the original object will be saved with that temporary name in
2593 the temporary directory. If the temporaryName parameter is not provided and
2594 the newName parameter is provided, the original object will be saved with
2595 its original name in the temporary directory.
2596
2597 The result object will have the data (or directory contents) from the
2598 replacement object, but will have the original object's creation date and
2599 backup date. By default, the result object will have extended attributes
2600 merged from the original object and the replacement object, using the extended
2601 attributes of the replacement object if the original object has extended
2602 attributes with the same name. If the kFSReplaceObjectReplaceMetadata option
2603 flag is passed, then the extended attributes of the original object will be
2604 completely overwritten by the extended attributes of the replacement object.
2605
2606 The kFSReplaceObjectReplaceMetadata also controls how the label, type, creator,
2607 hidden extension bit, strong binding, custom icon and custom badge are handled.
2608 For the custom icon, custom badge, label (where a value of 0 is considered not
2609 present), and strong binding the replacement object's attributes will be
2610 used if present, otherwise the original object's attributes will be retained. For
2611 the extension hidden bit, type, and creator the original object's attribute is
2612 preserved. Setting the kFSReplaceObjectReplaceMetadata flag will use the replacement
2613 object's attributes for all cases. Type and creator are only handled in the
2614 file to file case. Strong bindings are not applicable to plain directories.
2615
2616 The default handling of ACL and mode info depends on the types of objects
2617 involved. If the original object and replacement object are of the same type
2618 (both files or both directories) then the default behavior is to use the ACL
2619 and mode of the original object. Setting the kFSReplaceObjectReplacePermissionInfo
2620 flag will use the ACL and mode from the replacementObject.
2621
2622 If the objects are different types, then the ACL and mode will be based off
2623 the original object and will translated as follows:
2624
2625 Mode:
2626 file r -> dir rx
2627 file w -> dir wx
2628 file x -> dir nothing
2629
2630 dir r -> file r
2631 dir w -> file w
2632 dir x -> file nothing
2633
2634 ACLs:
2635
2636 ACL_SEARCH will be added to any allow ACE in the file to directory case.
2637 ACL_EXECUTE will be removed from any ACE in the file to directory case.
2638
2639 ACL_SEARCH and ACL_DELETE_CHILD will be removed from any ACE in the directory to file case.
2640
2641 File Directory
2642 ACL_READ_DATA <-> ACL_LIST_DIRECTORY
2643 ACL_WRITE_DATA <-> ACL_ADD_FILE
2644 ACL_APPEND_DATA <-> ACL_ADD_SUBDIRECTORY
2645
2646 ACL_DELETE , ACL_READ_ATTRIBUTES, ACL_WRITE_ATTRIBUTES, ACL_READ_EXTATTRIBUTES,
2647 ACL_WRITE_EXTATTRIBUTES, ACL_READ_SECURITY, ACL_WRITE_SECURITY and ACL_CHANGE_OWNER
2648 are the same for both types and will be left alone.
2649
2650 This translation behavior can be avoided by passing in either
2651 kFSReplaceObjectPreservePermissionInfo to use the original object ACL and
2652 mode info unchanged (except where the bits have different meanings for files
2653 and directories) or kFSReplaceObjectReplacePermissionInfo to use the ACL and
2654 mode info of the replacement object (except where the bits have different
2655 meanings for files and directories). Setting both of these flags is an
2656 error -- the call will fail with a paramErr. The permissions are only set on
2657 the top-level object -- the permissions inside a directory are unaffected.
2658
2659 FSReplaceObject may not be atomic -- it may issue multiple system calls to
2660 accurately replace and preserve the metadata of a file system object.
2661
2662 FSReplaceObject may fail if the source or destination files are open or
2663 the source or destination objects are directories which contain open files.
2664 }
2665
2666 {
2667 * FSReplaceObjectOptions
2668 *
2669 * Discussion:
2670 * Options that can be passed to the FSReplaceObject and
2671 * FSPathReplaceObject functions. These are mask values that can be
2672 * ORed together to set more than one option.
2673 }
2674 const
2675 {
2676 * Use the default behavior (see the discussion of the
2677 * FSReplaceObject function)
2678 }
2679 kFSReplaceObjectDefaultOptions = 0;
2680
2681 {
2682 * The result object will only have the metadata from the replacement
2683 * object. The result object will have no metadata from the original
2684 * object.
2685 }
2686 kFSReplaceObjectReplaceMetadata = $01;
2687
2688 {
2689 * The original object will be saved with the temporary name in the
2690 * temporaryDirectory, or will be saved with the original name (if no
2691 * temporaryName is provided and a newName is provided) in the
2692 * temporaryDirectory.
2693 }
2694 kFSReplaceObjectSaveOriginalAsABackup = $02;
2695
2696 {
2697 * ACL and mode info will come from the replacement object.
2698 }
2699 kFSReplaceObjectReplacePermissionInfo = $04;
2700
2701 {
2702 * ACL and mode info will come from the original object
2703 }
2704 kFSReplaceObjectPreservePermissionInfo = $08;
2705
2706 {
2707 * FSReplaceObject does not actually require write permission to
2708 * perform the replace operation, since no actual writing is done to
2709 * the original object. By default ReplaceObject will test the
2710 * object for write permissions and fail if they are not present
2711 * (tested using accessx_np). Write permission in this context is
2712 * defined as ACL_WRITE_DATA for files and ACL_ADD_FILE for
2713 * directories. Pass this flag to skip this check (which will allow
2714 * the replace to operate on "read only" objects).
2715 }
2716 kFSReplaceObjectDoNotCheckObjectWriteAccess = $10;
2717
2718 {
2719 * FSReplaceObject()
2720 *
2721 * Discussion:
2722 * This function will replace the object specified by originalObject
2723 * with the object specified by replacementObject. The result object
2724 * will be in the same parent directory as the original object.
2725 *
2726 * Mac OS X threading:
2727 * Thread safe since version 10.5
2728 *
2729 * Parameters:
2730 *
2731 * originalObject:
2732 * The original object to be replaced.
2733 *
2734 * replacementObject:
2735 * The object which will replace the original object.
2736 *
2737 * newName:
2738 * The new name for the result object. Pass NULL to use the
2739 * original object's name.
2740 *
2741 * temporaryName:
2742 * The name of a temporary object should the operation require a
2743 * temporary object. The temporary object will be created in the
2744 * preferred temporary directory or in the directory specified by
2745 * the temporaryDirectory parameter.
2746 *
2747 * temporaryDirectory:
2748 * The directory where the temporary object (if needed) will be
2749 * created. The temporary directory must be on the same volume as
2750 * the original object. If NULL is passed, then the preferred
2751 * temporary directory is used (as per
2752 * FSGetTemporaryDirectoryForReplaceObject).
2753 *
2754 * flags:
2755 * A set of options to specify non-default behavior.
2756 *
2757 * resultObject:
2758 * A new FSRef for the result object.
2759 *
2760 * Availability:
2761 * Mac OS X: in version 10.5 and later in CoreServices.framework
2762 * CarbonLib: not available
2763 * Non-Carbon CFM: not available
2764 }
FSReplaceObjectnull2765 function FSReplaceObject( const (*var*) originalObject: FSRef; const (*var*) replacementObject: FSRef; newName: CFStringRef; temporaryName: CFStringRef; temporaryDirectory: {const} FSRefPtr; flags: OptionBits; var resultObject: FSRef ): OSStatus; external name '_FSReplaceObject';
2766 (* __OSX_AVAILABLE_BUT_DEPRECATED_MSG(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA, "Use NSFileManager's -replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error: instead. WARNING: FSReplaceObject does not work correctly in sandboxed apps.") *)
2767
2768
2769 {
2770 * FSPathReplaceObject()
2771 *
2772 * Discussion:
2773 * This function will replace the object specified by
2774 * originalObjectPath with the object specified by
2775 * replacementObjectPath. The result object will be in the same
2776 * parent directory as the original object.
2777 *
2778 * Mac OS X threading:
2779 * Thread safe since version 10.5
2780 *
2781 * Parameters:
2782 *
2783 * originalObjectPath:
2784 * The path to the original object to be replaced.
2785 *
2786 * replacementObjectPath:
2787 * The path to the object which will replace the original object.
2788 *
2789 * newName:
2790 * The new name for the result object. Pass NULL to use the
2791 * original object's name.
2792 *
2793 * temporaryName:
2794 * The name of a temporary object should the operation require a
2795 * temporary object. The temporary object will be created in the
2796 * preferred temporary directory or in the directory specified by
2797 * the temporaryDirectory parameter.
2798 *
2799 * temporaryDirectoryPath:
2800 * The path to the directory where the temporary object (if
2801 * needed) will be created. The temporary directory must be on the
2802 * same volume as the original object. If NULL is passed, then the
2803 * preferred temporary directory is used (as per
2804 * FSPathGetTemporaryDirectoryForReplaceObject).
2805 *
2806 * flags:
2807 * A set of options to specify non-default behavior.
2808 *
2809 * Availability:
2810 * Mac OS X: in version 10.5 and later in CoreServices.framework
2811 * CarbonLib: not available
2812 * Non-Carbon CFM: not available
2813 }
FSPathReplaceObjectnull2814 function FSPathReplaceObject( originalObjectPath: ConstCStringPtr; replacementObjectPath: ConstCStringPtr; newName: CFStringRef; temporaryName: CFStringRef; temporaryDirectoryPath: ConstCStringPtr; flags: OptionBits ): OSStatus; external name '_FSPathReplaceObject';
2815 (* __OSX_AVAILABLE_BUT_DEPRECATED_MSG(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA, "Use NSFileManager's -replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error: instead. WARNING: FSPathReplaceObject does not work correctly in sandboxed apps.") *)
2816
2817
2818 {
2819 * FSGetTemporaryDirectoryForReplaceObject()
2820 *
2821 * Discussion:
2822 * This function will return the preferred directory for use as the
2823 * temporaryDirectory by FSReplaceObject. It will return an
2824 * appropriate temporary location or the parent directory of the
2825 * original object.
2826 *
2827 * Mac OS X threading:
2828 * Thread safe since version 10.5
2829 *
2830 * Parameters:
2831 *
2832 * originalObject:
2833 * The original object to be replaced.
2834 *
2835 * temporaryDirectory:
2836 * The preferred temporary directory.
2837 *
2838 * flags:
2839 * A set of options to specify non-default behavior. Currently no
2840 * flags are defined - pass in 0
2841 *
2842 * Availability:
2843 * Mac OS X: in version 10.5 and later in CoreServices.framework
2844 * CarbonLib: not available
2845 * Non-Carbon CFM: not available
2846 }
FSGetTemporaryDirectoryForReplaceObjectnull2847 function FSGetTemporaryDirectoryForReplaceObject( const (*var*) originalObject: FSRef; var temporaryDirectory: FSRef; flags: OptionBits ): OSStatus; external name '_FSGetTemporaryDirectoryForReplaceObject';
2848 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2849
2850
2851 {
2852 * FSPathGetTemporaryDirectoryForReplaceObject()
2853 *
2854 * Discussion:
2855 * This function will return the preferred directory for use as the
2856 * temporaryDirectory by FSPathReplaceObject. It will return an
2857 * appropriate temporary location or the parent directory of the
2858 * original object.
2859 *
2860 * Mac OS X threading:
2861 * Thread safe since version 10.5
2862 *
2863 * Parameters:
2864 *
2865 * originalObjectPath:
2866 * The path to the original object to be replaced.
2867 *
2868 * temporaryDirectoryPath:
2869 * The path to the preferred temporary directory.
2870 *
2871 * maxPathSize:
2872 * The size of the buffer pointed to by the temporaryDirectoryPath
2873 * parameter.
2874 *
2875 * flags:
2876 * A set of options to specify non-default behavior. Currently no
2877 * flags are defined - pass in 0
2878 *
2879 * Availability:
2880 * Mac OS X: in version 10.5 and later in CoreServices.framework
2881 * CarbonLib: not available
2882 * Non-Carbon CFM: not available
2883 }
FSPathGetTemporaryDirectoryForReplaceObjectnull2884 function FSPathGetTemporaryDirectoryForReplaceObject( originalObjectPath: ConstCStringPtr; temporaryDirectoryPath: CStringPtr; maxPathSize: UInt32; flags: OptionBits ): OSStatus; external name '_FSPathGetTemporaryDirectoryForReplaceObject';
2885 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2886
2887
2888 {
2889 RenameUnicode
2890 Change the name of an existing file or directory. The new name is in
2891 Unicode.
2892 -> ioCompletion A pointer to a completion routine
2893 <- ioResult The result code of the function
2894 -> ref The file or directory to be moved
2895 -> nameLength Number of Unicode characters in the new name
2896 -> name A pointer to the new Unicode name
2897 -> textEncodingHint A suggested text encoding to use for the name
2898 <- newRef A new FSRef for the file or directory; may be NULL
2899 NOTE: Renaming an object may change its FSRef. If you want to continue to
2900 refer to the object, you should pass a non-NULL pointer in newRef and use
2901 that returned FSRef to access the object after the rename. The FSRef passed
2902 in "ref" may or may not be usable to access the object after it is renamed.
2903 "newRef" may point to the same storage as "ref".
2904 }
2905 {
2906 * FSRenameUnicode()
2907 *
2908 * Mac OS X threading:
2909 * Thread safe since version 10.0
2910 *
2911 * Availability:
2912 * Mac OS X: in version 10.0 and later in CoreServices.framework
2913 * CarbonLib: in CarbonLib 1.0 and later
2914 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2915 }
FSRenameUnicodenull2916 function FSRenameUnicode( const (*var*) ref: FSRef; nameLength: UniCharCount; name: UniCharPtr; textEncodingHint: TextEncoding; newRef: FSRefPtr ): OSErr; external name '_FSRenameUnicode';
2917 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2918
2919
2920 {
2921 * PBRenameUnicodeSync()
2922 *
2923 * Mac OS X threading:
2924 * Thread safe since version 10.0
2925 *
2926 * Availability:
2927 * Mac OS X: in version 10.0 and later in CoreServices.framework
2928 * CarbonLib: in CarbonLib 1.0 and later
2929 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2930 }
PBRenameUnicodeSyncnull2931 function PBRenameUnicodeSync( var paramBlock: FSRefParam ): OSErr; external name '_PBRenameUnicodeSync';
2932 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2933
2934
2935 {
2936 * PBRenameUnicodeAsync()
2937 *
2938 * Mac OS X threading:
2939 * Thread safe since version 10.0
2940 *
2941 * Availability:
2942 * Mac OS X: in version 10.0 and later in CoreServices.framework
2943 * CarbonLib: in CarbonLib 1.0 and later
2944 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2945 }
2946 procedure PBRenameUnicodeAsync( var paramBlock: FSRefParam ); external name '_PBRenameUnicodeAsync';
2947 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2948
2949
2950 {
2951 GetCatalogInfo
2952 Returns various information about a given file or directory.
2953 -> ioCompletion A pointer to a completion routine
2954 <- ioResult The result code of the function
2955 -> ref The file or directory whose information is to be returned
2956 -> whichInfo Which catalog info fields to get
2957 <- catInfo The returned values of catalog info fields; may be NULL
2958 <- spec A pointer to the FSSpec for the object; may be NULL. Ignored for 64 bit.
2959 <- parentRef A pointer to the FSRef for the object's parent directory; may be NULL
2960 <- outName The Unicode name is returned here. This pointer may be NULL.
2961 Note: All of the outputs are optional; if you don't want that particular output, just
2962 set its pointer to NULL. This is the call to use to map from an FSRef to an FSSpec.
2963 }
2964 {
2965 * FSGetCatalogInfo()
2966 *
2967 * Mac OS X threading:
2968 * Thread safe since version 10.0
2969 *
2970 * Availability:
2971 * Mac OS X: in version 10.0 and later in CoreServices.framework
2972 * CarbonLib: in CarbonLib 1.0 and later
2973 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2974 }
FSGetCatalogInfonull2975 function FSGetCatalogInfo( const (*var*) ref: FSRef; whichInfo: FSCatalogInfoBitmap; catalogInfo: FSCatalogInfoPtr; outName: HFSUniStr255Ptr; fsSpec: FSSpecPtr; parentRef: FSRefPtr ): OSErr; external name '_FSGetCatalogInfo';
2976 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2977
2978
2979 {
2980 * PBGetCatalogInfoSync()
2981 *
2982 * Mac OS X threading:
2983 * Thread safe since version 10.0
2984 *
2985 * Availability:
2986 * Mac OS X: in version 10.0 and later in CoreServices.framework
2987 * CarbonLib: in CarbonLib 1.0 and later
2988 * Non-Carbon CFM: in InterfaceLib 9.0 and later
2989 }
PBGetCatalogInfoSyncnull2990 function PBGetCatalogInfoSync( var paramBlock: FSRefParam ): OSErr; external name '_PBGetCatalogInfoSync';
2991 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
2992
2993
2994 {
2995 * PBGetCatalogInfoAsync()
2996 *
2997 * Mac OS X threading:
2998 * Thread safe since version 10.0
2999 *
3000 * Availability:
3001 * Mac OS X: in version 10.0 and later in CoreServices.framework
3002 * CarbonLib: in CarbonLib 1.0 and later
3003 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3004 }
3005 procedure PBGetCatalogInfoAsync( var paramBlock: FSRefParam ); external name '_PBGetCatalogInfoAsync';
3006 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3007
3008
3009 {
3010 * FSSetCatalogInfo()
3011 *
3012 * Summary:
3013 * Set catalog information about a given file or directory.
3014 *
3015 * Discussion:
3016 * Set the catalog information for the file or directory represented
3017 * by ref.
3018 *
3019 * Mac OS X threading:
3020 * Thread safe since version 10.0
3021 *
3022 * Parameters:
3023 *
3024 * ref:
3025 * A pointer to an FSRef specifying the file or directory whose
3026 * information is to be changed
3027 *
3028 * whichInfo:
3029 * A bitmap specifying which catalog information fields may be
3030 * set. The settable fields are given by the constant
3031 * kFSCatInfoSettableInfo; no other bits may be set in whichInfo.
3032 * The one exception to this is that processes running as eid 0 or
3033 * euid 0 can change the user ID and group ID of a file or
3034 * directory by setting kFSCatInfoSetOwnership in whichInfo and
3035 * setting the permissions field of catalogInfo.
3036 *
3037 * catalogInfo:
3038 * A pointer to the structure containing the new catalog
3039 * information. Only some of the catalog information fields may be
3040 * set.
3041 *
3042 * Availability:
3043 * Mac OS X: in version 10.0 and later in CoreServices.framework
3044 * CarbonLib: in CarbonLib 1.0 and later
3045 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3046 }
FSSetCatalogInfonull3047 function FSSetCatalogInfo( const (*var*) ref: FSRef; whichInfo: FSCatalogInfoBitmap; const (*var*) catalogInfo: FSCatalogInfo ): OSErr; external name '_FSSetCatalogInfo';
3048 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3049
3050
3051 {
3052 * PBSetCatalogInfoSync()
3053 *
3054 * Summary:
3055 * Set catalog information about a given file or directory.
3056 *
3057 * Discussion:
3058 * Set the catalog information for the file or directory represented
3059 * by ref. See the description in FSSetCatalogInfo for which items
3060 * may be set.
3061 *
3062 * Mac OS X threading:
3063 * Thread safe since version 10.0
3064 *
3065 * Availability:
3066 * Mac OS X: in version 10.0 and later in CoreServices.framework
3067 * CarbonLib: in CarbonLib 1.0 and later
3068 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3069 }
PBSetCatalogInfoSyncnull3070 function PBSetCatalogInfoSync( var paramBlock: FSRefParam ): OSErr; external name '_PBSetCatalogInfoSync';
3071 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3072
3073
3074 {
3075 * PBSetCatalogInfoAsync()
3076 *
3077 * Summary:
3078 * Set catalog information about a given file or directory.
3079 *
3080 * Discussion:
3081 * Set the catalog information for the file or directory represented
3082 * by ref. See the description in FSSetCatalogInfo for which items
3083 * may be set.
3084 *
3085 * Mac OS X threading:
3086 * Thread safe since version 10.0
3087 *
3088 * Availability:
3089 * Mac OS X: in version 10.0 and later in CoreServices.framework
3090 * CarbonLib: in CarbonLib 1.0 and later
3091 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3092 }
3093 procedure PBSetCatalogInfoAsync( var paramBlock: FSRefParam ); external name '_PBSetCatalogInfoAsync';
3094 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3095
3096
3097 {
3098 OpenIterator
3099 Creates an FSIterator to iterate over a directory or subtree. The
3100 iterator can then be passed to GetCatalogInfoBulk or CatalogSearch.
3101 -> ioCompletion A pointer to a completion routine
3102 <- ioResult The result code of the function
3103 <- iterator The returned FSIterator
3104 -> iteratorFlags Controls whether the iterator iterates over subtrees
3105 or just the immediate children of the container.
3106 -> container An FSRef for the directory to iterate (or root of
3107 the subtree to iterate).
3108 }
3109 {
3110 * FSOpenIterator()
3111 *
3112 * Mac OS X threading:
3113 * Thread safe since version 10.0
3114 *
3115 * Availability:
3116 * Mac OS X: in version 10.0 and later in CoreServices.framework
3117 * CarbonLib: in CarbonLib 1.0 and later
3118 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3119 }
FSOpenIteratornull3120 function FSOpenIterator( const (*var*) container: FSRef; iteratorFlags: FSIteratorFlags; var iterator: FSIterator ): OSErr; external name '_FSOpenIterator';
3121 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3122
3123
3124 {
3125 * PBOpenIteratorSync()
3126 *
3127 * Mac OS X threading:
3128 * Thread safe since version 10.0
3129 *
3130 * Availability:
3131 * Mac OS X: in version 10.0 and later in CoreServices.framework
3132 * CarbonLib: in CarbonLib 1.0 and later
3133 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3134 }
PBOpenIteratorSyncnull3135 function PBOpenIteratorSync( var paramBlock: FSCatalogBulkParam ): OSErr; external name '_PBOpenIteratorSync';
3136 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3137
3138
3139 {
3140 * PBOpenIteratorAsync()
3141 *
3142 * Mac OS X threading:
3143 * Thread safe since version 10.0
3144 *
3145 * Availability:
3146 * Mac OS X: in version 10.0 and later in CoreServices.framework
3147 * CarbonLib: in CarbonLib 1.0 and later
3148 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3149 }
3150 procedure PBOpenIteratorAsync( var paramBlock: FSCatalogBulkParam ); external name '_PBOpenIteratorAsync';
3151 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3152
3153
3154 {
3155 CloseIterator
3156 Invalidates and disposes an FSIterator.
3157 -> ioCompletion A pointer to a completion routine
3158 <- ioResult The result code of the function
3159 -> iterator The returned FSIterator
3160 }
3161 {
3162 * FSCloseIterator()
3163 *
3164 * Mac OS X threading:
3165 * Thread safe since version 10.0
3166 *
3167 * Availability:
3168 * Mac OS X: in version 10.0 and later in CoreServices.framework
3169 * CarbonLib: in CarbonLib 1.0 and later
3170 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3171 }
FSCloseIteratornull3172 function FSCloseIterator( iterator: FSIterator ): OSErr; external name '_FSCloseIterator';
3173 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3174
3175
3176 {
3177 * PBCloseIteratorSync()
3178 *
3179 * Mac OS X threading:
3180 * Thread safe since version 10.0
3181 *
3182 * Availability:
3183 * Mac OS X: in version 10.0 and later in CoreServices.framework
3184 * CarbonLib: in CarbonLib 1.0 and later
3185 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3186 }
PBCloseIteratorSyncnull3187 function PBCloseIteratorSync( var paramBlock: FSCatalogBulkParam ): OSErr; external name '_PBCloseIteratorSync';
3188 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3189
3190
3191 {
3192 * PBCloseIteratorAsync()
3193 *
3194 * Mac OS X threading:
3195 * Thread safe since version 10.0
3196 *
3197 * Availability:
3198 * Mac OS X: in version 10.0 and later in CoreServices.framework
3199 * CarbonLib: in CarbonLib 1.0 and later
3200 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3201 }
3202 procedure PBCloseIteratorAsync( var paramBlock: FSCatalogBulkParam ); external name '_PBCloseIteratorAsync';
3203 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3204
3205
3206 {
3207 GetCatalogInfoBulk
3208 Iterates over catalog objects and returns information about them.
3209 For now, iterator must have been created with kFSIterateFlat option.
3210 -> ioCompletion A pointer to a completion routine
3211 <- ioResult The result code of the function
3212 -> iterator The iterator
3213 -> maximumItems The maximum number of items to return
3214 <- actualItems The actual number of items returned
3215 <- containerChanged Set to true if the container's contents changed
3216 -> whichInfo The catalog information fields to return for each item
3217 <- catalogInfo An array of catalog information; one for each returned item
3218 <- refs An array of FSRefs; one for each returned item
3219 <- specs An array of FSSpecs; one for each returned item. Ignored on 64 bit.
3220 <- names An array of filenames; one for each returned item
3221 Note: The catalogInfo, refs, specs, names, and containerChanged are all optional outputs;
3222 if you don't want that particular output, set its pointer to NULL.
3223 }
3224 {
3225 * FSGetCatalogInfoBulk()
3226 *
3227 * Mac OS X threading:
3228 * Thread safe since version 10.0
3229 *
3230 * Availability:
3231 * Mac OS X: in version 10.0 and later in CoreServices.framework
3232 * CarbonLib: in CarbonLib 1.0 and later
3233 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3234 }
FSGetCatalogInfoBulknull3235 function FSGetCatalogInfoBulk( iterator: FSIterator; maximumObjects: ItemCount; var actualObjects: ItemCount; containerChanged: BooleanPtr; whichInfo: FSCatalogInfoBitmap; catalogInfos: FSCatalogInfoPtr; refs: FSRefPtr; specs: FSSpecPtr; names: HFSUniStr255Ptr ): OSErr; external name '_FSGetCatalogInfoBulk';
3236 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3237
3238
3239 {
3240 * PBGetCatalogInfoBulkSync()
3241 *
3242 * Mac OS X threading:
3243 * Thread safe since version 10.0
3244 *
3245 * Availability:
3246 * Mac OS X: in version 10.0 and later in CoreServices.framework
3247 * CarbonLib: in CarbonLib 1.0 and later
3248 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3249 }
PBGetCatalogInfoBulkSyncnull3250 function PBGetCatalogInfoBulkSync( var paramBlock: FSCatalogBulkParam ): OSErr; external name '_PBGetCatalogInfoBulkSync';
3251 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3252
3253
3254 {
3255 * PBGetCatalogInfoBulkAsync()
3256 *
3257 * Mac OS X threading:
3258 * Thread safe since version 10.0
3259 *
3260 * Availability:
3261 * Mac OS X: in version 10.0 and later in CoreServices.framework
3262 * CarbonLib: in CarbonLib 1.0 and later
3263 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3264 }
3265 procedure PBGetCatalogInfoBulkAsync( var paramBlock: FSCatalogBulkParam ); external name '_PBGetCatalogInfoBulkAsync';
3266 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3267
3268
3269 {
3270 CatalogSearch
3271 Iterates over catalog objects, searching for objects that match given
3272 search criteria. Returns various information about matching objects.
3273 For now, iterator must have been created with kFSIterateSubtree option
3274 and the container must have been the root directory of a volume.
3275 -> ioCompletion A pointer to a completion routine
3276 <- ioResult The result code of the function
3277 -> iterator The iterator
3278 -> maximumItems The maximum number of items to return
3279 <- actualItems The actual number of items returned
3280 <- containerChanged Set to true if the container's contents changed
3281 -> whichInfo The catalog information fields to return for each item
3282 <- catalogInfo An array of catalog information; one for each returned item
3283 <- refs An array of FSRefs; one for each returned item
3284 <- specs An array of FSSpecs; one for each returned item. Ignored on 64 bit.
3285 <- names An array of filenames; one for each returned item
3286 -> searchParams The criteria that controls the matching, including timeout, a bitmap
3287 controlling the fields to compare, and the (Unicode) name to compare.
3288 Note: The catalogInfo, refs, specs, and names are all optional outputs; if you don't want
3289 that particular output, set its pointer to NULL.
3290 }
3291 {
3292 * FSCatalogSearch()
3293 *
3294 * Mac OS X threading:
3295 * Thread safe since version 10.0
3296 *
3297 * Availability:
3298 * Mac OS X: in version 10.0 and later in CoreServices.framework
3299 * CarbonLib: in CarbonLib 1.0 and later
3300 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3301 }
FSCatalogSearchnull3302 function FSCatalogSearch( iterator: FSIterator; const (*var*) searchCriteria: FSSearchParams; maximumObjects: ItemCount; var actualObjects: ItemCount; containerChanged: BooleanPtr; whichInfo: FSCatalogInfoBitmap; catalogInfos: FSCatalogInfoPtr; refs: FSRefPtr; specs: FSSpecPtr; names: HFSUniStr255Ptr ): OSErr; external name '_FSCatalogSearch';
3303 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3304
3305
3306 {
3307 * PBCatalogSearchSync()
3308 *
3309 * Mac OS X threading:
3310 * Thread safe since version 10.0
3311 *
3312 * Availability:
3313 * Mac OS X: in version 10.0 and later in CoreServices.framework
3314 * CarbonLib: in CarbonLib 1.0 and later
3315 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3316 }
PBCatalogSearchSyncnull3317 function PBCatalogSearchSync( var paramBlock: FSCatalogBulkParam ): OSErr; external name '_PBCatalogSearchSync';
3318 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3319
3320
3321 {
3322 * PBCatalogSearchAsync()
3323 *
3324 * Mac OS X threading:
3325 * Thread safe since version 10.0
3326 *
3327 * Availability:
3328 * Mac OS X: in version 10.0 and later in CoreServices.framework
3329 * CarbonLib: in CarbonLib 1.0 and later
3330 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3331 }
3332 procedure PBCatalogSearchAsync( var paramBlock: FSCatalogBulkParam ); external name '_PBCatalogSearchAsync';
3333 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3334
3335
3336 {
3337 CreateFileAndOpenForkUnicode
3338 Creates a new file and opens the specified fork. The input filename is in Unicode.
3339 You can optionally set catalog info for the file.
3340 -> ioCompletion A pointer to a completion routine
3341 <- ioResult The result code of the function
3342 -> parentRef The directory where the file is to be created
3343 -> whichInfo Which catalog info fields to set
3344 -> catalogInfo The values for catalog info fields to set; may be NULL
3345 -> nameLength Number of Unicode characters in the file's name
3346 -> name A pointer to the Unicode name
3347 -> forkNameLength The length of the fork name (in Unicode characters).
3348 -> forkName The name of the fork to open (in Unicode). Passing NULL will open the data fork.
3349 -> permissions The access (read and/or write) you want
3350 <- forkRefNum The reference number for accessing the open fork
3351 <- newRef A pointer to the FSRef for the new file; may be NULL
3352 }
3353 {
3354 * FSCreateFileAndOpenForkUnicode()
3355 *
3356 * Mac OS X threading:
3357 * Thread safe since version 10.4
3358 *
3359 * Availability:
3360 * Mac OS X: in version 10.4 and later in CoreServices.framework
3361 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
3362 * Non-Carbon CFM: not available
3363 }
FSCreateFileAndOpenForkUnicodenull3364 function FSCreateFileAndOpenForkUnicode( const (*var*) parentRef: FSRef; nameLength: UniCharCount; name: {const} UniCharPtr; whichInfo: FSCatalogInfoBitmap; catalogInfo: FSCatalogInfoPtr; forkNameLength: UniCharCount; forkName: {const} UniCharPtr; permissions: SInt8; var forkRefNum: FSIORefNum; newRef: FSRefPtr ): OSStatus; external name '_FSCreateFileAndOpenForkUnicode';
3365 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3366
3367
3368 {
3369 * PBCreateFileAndOpenForkUnicodeSync()
3370 *
3371 * Mac OS X threading:
3372 * Thread safe since version 10.4
3373 *
3374 * Availability:
3375 * Mac OS X: in version 10.4 and later in CoreServices.framework
3376 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
3377 * Non-Carbon CFM: not available
3378 }
PBCreateFileAndOpenForkUnicodeSyncnull3379 function PBCreateFileAndOpenForkUnicodeSync( paramBlock: FSRefForkIOParamPtr ): OSStatus; external name '_PBCreateFileAndOpenForkUnicodeSync';
3380 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3381
3382
3383 {
3384 * PBCreateFileAndOpenForkUnicodeAsync()
3385 *
3386 * Mac OS X threading:
3387 * Thread safe since version 10.4
3388 *
3389 * Availability:
3390 * Mac OS X: in version 10.4 and later in CoreServices.framework
3391 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
3392 * Non-Carbon CFM: not available
3393 }
3394 procedure PBCreateFileAndOpenForkUnicodeAsync( paramBlock: FSRefForkIOParamPtr ); external name '_PBCreateFileAndOpenForkUnicodeAsync';
3395 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3396
3397
3398 {
3399 CreateFork
3400 Create a named fork for a file or directory.
3401 -> ioCompletion A pointer to a completion routine
3402 <- ioResult The result code of the function
3403 -> ref The file or directory
3404 -> forkNameLength The length of the fork name (in Unicode characters)
3405 -> forkName The name of the fork to open (in Unicode)
3406 }
3407 {
3408 * FSCreateFork()
3409 *
3410 * Mac OS X threading:
3411 * Thread safe since version 10.0
3412 *
3413 * Availability:
3414 * Mac OS X: in version 10.0 and later in CoreServices.framework
3415 * CarbonLib: in CarbonLib 1.0 and later
3416 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3417 }
FSCreateForknull3418 function FSCreateFork( const (*var*) ref: FSRef; forkNameLength: UniCharCount; forkName: UniCharPtr ): OSErr; external name '_FSCreateFork';
3419 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3420
3421
3422 {
3423 * PBCreateForkSync()
3424 *
3425 * Mac OS X threading:
3426 * Thread safe since version 10.0
3427 *
3428 * Availability:
3429 * Mac OS X: in version 10.0 and later in CoreServices.framework
3430 * CarbonLib: in CarbonLib 1.0 and later
3431 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3432 }
PBCreateForkSyncnull3433 function PBCreateForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBCreateForkSync';
3434 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3435
3436
3437 {
3438 * PBCreateForkAsync()
3439 *
3440 * Mac OS X threading:
3441 * Thread safe since version 10.0
3442 *
3443 * Availability:
3444 * Mac OS X: in version 10.0 and later in CoreServices.framework
3445 * CarbonLib: in CarbonLib 1.0 and later
3446 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3447 }
3448 procedure PBCreateForkAsync( var paramBlock: FSForkIOParam ); external name '_PBCreateForkAsync';
3449 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3450
3451
3452 {
3453 DeleteFork
3454 Delete a named fork of a file or directory.
3455 -> ioCompletion A pointer to a completion routine
3456 <- ioResult The result code of the function
3457 -> ref The file or directory
3458 -> forkNameLength The length of the fork name (in Unicode characters)
3459 -> forkName The name of the fork to open (in Unicode)
3460 }
3461 {
3462 * FSDeleteFork()
3463 *
3464 * Mac OS X threading:
3465 * Thread safe since version 10.0
3466 *
3467 * Availability:
3468 * Mac OS X: in version 10.0 and later in CoreServices.framework
3469 * CarbonLib: in CarbonLib 1.0 and later
3470 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3471 }
FSDeleteForknull3472 function FSDeleteFork( const (*var*) ref: FSRef; forkNameLength: UniCharCount; forkName: UniCharPtr ): OSErr; external name '_FSDeleteFork';
3473 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3474
3475
3476 {
3477 * PBDeleteForkSync()
3478 *
3479 * Mac OS X threading:
3480 * Thread safe since version 10.0
3481 *
3482 * Availability:
3483 * Mac OS X: in version 10.0 and later in CoreServices.framework
3484 * CarbonLib: in CarbonLib 1.0 and later
3485 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3486 }
PBDeleteForkSyncnull3487 function PBDeleteForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBDeleteForkSync';
3488 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3489
3490
3491 {
3492 * PBDeleteForkAsync()
3493 *
3494 * Mac OS X threading:
3495 * Thread safe since version 10.0
3496 *
3497 * Availability:
3498 * Mac OS X: in version 10.0 and later in CoreServices.framework
3499 * CarbonLib: in CarbonLib 1.0 and later
3500 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3501 }
3502 procedure PBDeleteForkAsync( var paramBlock: FSForkIOParam ); external name '_PBDeleteForkAsync';
3503 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3504
3505
3506 {
3507 IterateForks
3508 Return the names and sizes of the forks of a file or directory.
3509 One fork is returned per call.
3510 -> ioCompletion A pointer to a completion routine.
3511 <- ioResult The result code of the function.
3512 -> ref The file or directory containing the forks.
3513 <- positionOffset The length of the fork, in bytes.
3514 <- allocationAmount The space allocated to the fork (physical length).
3515 <- outForkName The name of the fork in Unicode.
3516 <> forkIterator Maintains state between calls for a given FSRef.
3517 Before the first call, set the initialize field to zero.
3518 }
3519 {
3520 * FSIterateForks()
3521 *
3522 * Mac OS X threading:
3523 * Thread safe since version 10.0
3524 *
3525 * Availability:
3526 * Mac OS X: in version 10.0 and later in CoreServices.framework
3527 * CarbonLib: in CarbonLib 1.0 and later
3528 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3529 }
FSIterateForksnull3530 function FSIterateForks( const (*var*) ref: FSRef; var forkIterator: CatPositionRec; forkName: HFSUniStr255Ptr; forkSize: SInt64Ptr; forkPhysicalSize: UInt64Ptr ): OSErr; external name '_FSIterateForks';
3531 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3532
3533 {
3534 * PBIterateForksSync()
3535 *
3536 * Mac OS X threading:
3537 * Thread safe since version 10.0
3538 *
3539 * Availability:
3540 * Mac OS X: in version 10.0 and later in CoreServices.framework
3541 * CarbonLib: in CarbonLib 1.0 and later
3542 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3543 }
PBIterateForksSyncnull3544 function PBIterateForksSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBIterateForksSync';
3545 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3546
3547
3548 {
3549 * PBIterateForksAsync()
3550 *
3551 * Mac OS X threading:
3552 * Thread safe since version 10.0
3553 *
3554 * Availability:
3555 * Mac OS X: in version 10.0 and later in CoreServices.framework
3556 * CarbonLib: in CarbonLib 1.0 and later
3557 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3558 }
3559 procedure PBIterateForksAsync( var paramBlock: FSForkIOParam ); external name '_PBIterateForksAsync';
3560 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3561
3562
3563 {
3564 OpenFork
3565 Open a fork for reading and/or writing. Allows the opened fork
3566 to grow beyond 2GB in size. All volumes should support data and
3567 resource forks. Other named forks may be supported by some
3568 volumes.
3569 -> ioCompletion A pointer to a completion routine
3570 <- ioResult The result code of the function
3571 -> ref The file or directory containing the fork to open
3572 -> forkNameLength The length of the fork name (in Unicode characters)
3573 -> forkName The name of the fork to open (in Unicode)
3574 -> permissions The access (read and/or write) you want
3575 <- forkRefNum The reference number for accessing the open fork
3576 }
3577 {
3578 * FSOpenFork()
3579 *
3580 * Mac OS X threading:
3581 * Thread safe since version 10.0
3582 *
3583 * Availability:
3584 * Mac OS X: in version 10.0 and later in CoreServices.framework
3585 * CarbonLib: in CarbonLib 1.0 and later
3586 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3587 }
FSOpenForknull3588 function FSOpenFork( const (*var*) ref: FSRef; forkNameLength: UniCharCount; forkName: UniCharPtr; permissions: SInt8; var forkRefNum: FSIORefNum ): OSErr; external name '_FSOpenFork';
3589 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3590
3591
3592 {
3593 * PBOpenForkSync()
3594 *
3595 * Mac OS X threading:
3596 * Thread safe since version 10.0
3597 *
3598 * Availability:
3599 * Mac OS X: in version 10.0 and later in CoreServices.framework
3600 * CarbonLib: in CarbonLib 1.0 and later
3601 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3602 }
PBOpenForkSyncnull3603 function PBOpenForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBOpenForkSync';
3604 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3605
3606
3607 {
3608 * PBOpenForkAsync()
3609 *
3610 * Mac OS X threading:
3611 * Thread safe since version 10.0
3612 *
3613 * Availability:
3614 * Mac OS X: in version 10.0 and later in CoreServices.framework
3615 * CarbonLib: in CarbonLib 1.0 and later
3616 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3617 }
3618 procedure PBOpenForkAsync( var paramBlock: FSForkIOParam ); external name '_PBOpenForkAsync';
3619 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3620
3621
3622 {
3623 ReadFork
3624 Read data from a fork opened via OpenFork. The first byte to read is
3625 indicated by a combination of positionMode and positionOffset.
3626 -> ioCompletion A pointer to a completion routine
3627 <- ioResult The result code of the function
3628 -> forkRefNum The reference number of the fork to read from
3629 <- buffer Pointer to buffer where data will be returned
3630 -> requestCount The number of bytes to read
3631 <- actualCount The number of bytes actually read
3632 -> positionMode The base location for start of read
3633 -> positionOffset The offset from base location for start of read
3634 }
3635 {
3636 * FSReadFork()
3637 *
3638 * Mac OS X threading:
3639 * Thread safe since version 10.0
3640 *
3641 * Availability:
3642 * Mac OS X: in version 10.0 and later in CoreServices.framework
3643 * CarbonLib: in CarbonLib 1.0 and later
3644 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3645 }
FSReadForknull3646 function FSReadFork( forkRefNum: FSIORefNum; positionMode: UInt16; positionOffset: SInt64; requestCount: ByteCount; buffer: UnivPtr; actualCount: ByteCountPtr ): OSErr; external name '_FSReadFork';
3647 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3648
3649
3650 {
3651 * PBReadForkSync()
3652 *
3653 * Mac OS X threading:
3654 * Thread safe since version 10.0
3655 *
3656 * Availability:
3657 * Mac OS X: in version 10.0 and later in CoreServices.framework
3658 * CarbonLib: in CarbonLib 1.0 and later
3659 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3660 }
PBReadForkSyncnull3661 function PBReadForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBReadForkSync';
3662 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3663
3664
3665 {
3666 * PBReadForkAsync()
3667 *
3668 * Mac OS X threading:
3669 * Thread safe since version 10.0
3670 *
3671 * Availability:
3672 * Mac OS X: in version 10.0 and later in CoreServices.framework
3673 * CarbonLib: in CarbonLib 1.0 and later
3674 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3675 }
3676 procedure PBReadForkAsync( var paramBlock: FSForkIOParam ); external name '_PBReadForkAsync';
3677 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3678
3679
3680 {
3681 WriteFork
3682 Write data to a fork opened via OpenFork. The first byte to write is
3683 indicated by a combination of positionMode and positionOffset.
3684 -> ioCompletion A pointer to a completion routine
3685 <- ioResult The result code of the function
3686 -> forkRefNum The reference number of the fork to write to
3687 -> buffer Pointer to data to write
3688 -> requestCount The number of bytes to write
3689 <- actualCount The number of bytes actually written
3690 -> positionMode The base location for start of write
3691 -> positionOffset The offset from base location for start of write
3692 }
3693 {
3694 * FSWriteFork()
3695 *
3696 * Mac OS X threading:
3697 * Thread safe since version 10.0
3698 *
3699 * Availability:
3700 * Mac OS X: in version 10.0 and later in CoreServices.framework
3701 * CarbonLib: in CarbonLib 1.0 and later
3702 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3703 }
FSWriteForknull3704 function FSWriteFork( forkRefNum: FSIORefNum; positionMode: UInt16; positionOffset: SInt64; requestCount: ByteCount; buffer: UnivPtr; actualCount: ByteCountPtr ): OSErr; external name '_FSWriteFork';
3705 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3706
3707
3708 {
3709 * PBWriteForkSync()
3710 *
3711 * Mac OS X threading:
3712 * Thread safe since version 10.0
3713 *
3714 * Availability:
3715 * Mac OS X: in version 10.0 and later in CoreServices.framework
3716 * CarbonLib: in CarbonLib 1.0 and later
3717 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3718 }
PBWriteForkSyncnull3719 function PBWriteForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBWriteForkSync';
3720 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3721
3722
3723 {
3724 * PBWriteForkAsync()
3725 *
3726 * Mac OS X threading:
3727 * Thread safe since version 10.0
3728 *
3729 * Availability:
3730 * Mac OS X: in version 10.0 and later in CoreServices.framework
3731 * CarbonLib: in CarbonLib 1.0 and later
3732 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3733 }
3734 procedure PBWriteForkAsync( var paramBlock: FSForkIOParam ); external name '_PBWriteForkAsync';
3735 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3736
3737
3738 {
3739 GetForkPosition
3740 Get the current (default) position of a fork that was
3741 opened via OpenFork.
3742 -> ioCompletion A pointer to a completion routine
3743 <- ioResult The result code of the function
3744 -> forkRefNum The reference number of the fork
3745 <- positionOffset The current position of the fork
3746 }
3747 {
3748 * FSGetForkPosition()
3749 *
3750 * Mac OS X threading:
3751 * Thread safe since version 10.0
3752 *
3753 * Availability:
3754 * Mac OS X: in version 10.0 and later in CoreServices.framework
3755 * CarbonLib: in CarbonLib 1.0 and later
3756 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3757 }
FSGetForkPositionnull3758 function FSGetForkPosition( forkRefNum: FSIORefNum; var position: SInt64 ): OSErr; external name '_FSGetForkPosition';
3759 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3760
3761
3762 {
3763 * PBGetForkPositionSync()
3764 *
3765 * Mac OS X threading:
3766 * Thread safe since version 10.0
3767 *
3768 * Availability:
3769 * Mac OS X: in version 10.0 and later in CoreServices.framework
3770 * CarbonLib: in CarbonLib 1.0 and later
3771 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3772 }
PBGetForkPositionSyncnull3773 function PBGetForkPositionSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBGetForkPositionSync';
3774 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3775
3776
3777 {
3778 * PBGetForkPositionAsync()
3779 *
3780 * Mac OS X threading:
3781 * Thread safe since version 10.0
3782 *
3783 * Availability:
3784 * Mac OS X: in version 10.0 and later in CoreServices.framework
3785 * CarbonLib: in CarbonLib 1.0 and later
3786 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3787 }
3788 procedure PBGetForkPositionAsync( var paramBlock: FSForkIOParam ); external name '_PBGetForkPositionAsync';
3789 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3790
3791
3792 {
3793 SetForkPosition
3794 Set the current (default) position of a fork that was
3795 opened via OpenFork.
3796 -> ioCompletion A pointer to a completion routine
3797 <- ioResult The result code of the function
3798 -> forkRefNum The reference number of the fork
3799 -> positionMode The base location for the new position
3800 -> positionOffset The offset of the new position from the base
3801 }
3802 {
3803 * FSSetForkPosition()
3804 *
3805 * Mac OS X threading:
3806 * Thread safe since version 10.0
3807 *
3808 * Availability:
3809 * Mac OS X: in version 10.0 and later in CoreServices.framework
3810 * CarbonLib: in CarbonLib 1.0 and later
3811 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3812 }
FSSetForkPositionnull3813 function FSSetForkPosition( forkRefNum: FSIORefNum; positionMode: UInt16; positionOffset: SInt64 ): OSErr; external name '_FSSetForkPosition';
3814 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3815
3816
3817 {
3818 * PBSetForkPositionSync()
3819 *
3820 * Mac OS X threading:
3821 * Thread safe since version 10.0
3822 *
3823 * Availability:
3824 * Mac OS X: in version 10.0 and later in CoreServices.framework
3825 * CarbonLib: in CarbonLib 1.0 and later
3826 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3827 }
PBSetForkPositionSyncnull3828 function PBSetForkPositionSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBSetForkPositionSync';
3829 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3830
3831
3832 {
3833 * PBSetForkPositionAsync()
3834 *
3835 * Mac OS X threading:
3836 * Thread safe since version 10.0
3837 *
3838 * Availability:
3839 * Mac OS X: in version 10.0 and later in CoreServices.framework
3840 * CarbonLib: in CarbonLib 1.0 and later
3841 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3842 }
3843 procedure PBSetForkPositionAsync( var paramBlock: FSForkIOParam ); external name '_PBSetForkPositionAsync';
3844 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3845
3846
3847 {
3848 GetForkSize
3849 Get the current logical size (end-of-file) of an open fork.
3850 -> ioCompletion A pointer to a completion routine
3851 <- ioResult The result code of the function
3852 -> forkRefNum The reference number of the fork
3853 <- positionOffset The logical size of the fork, in bytes
3854 }
3855 {
3856 * FSGetForkSize()
3857 *
3858 * Mac OS X threading:
3859 * Thread safe since version 10.0
3860 *
3861 * Availability:
3862 * Mac OS X: in version 10.0 and later in CoreServices.framework
3863 * CarbonLib: in CarbonLib 1.0 and later
3864 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3865 }
FSGetForkSizenull3866 function FSGetForkSize( forkRefNum: FSIORefNum; var forkSize: SInt64 ): OSErr; external name '_FSGetForkSize';
3867 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3868
3869
3870 {
3871 * PBGetForkSizeSync()
3872 *
3873 * Mac OS X threading:
3874 * Thread safe since version 10.0
3875 *
3876 * Availability:
3877 * Mac OS X: in version 10.0 and later in CoreServices.framework
3878 * CarbonLib: in CarbonLib 1.0 and later
3879 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3880 }
PBGetForkSizeSyncnull3881 function PBGetForkSizeSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBGetForkSizeSync';
3882 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3883
3884
3885 {
3886 * PBGetForkSizeAsync()
3887 *
3888 * Mac OS X threading:
3889 * Thread safe since version 10.0
3890 *
3891 * Availability:
3892 * Mac OS X: in version 10.0 and later in CoreServices.framework
3893 * CarbonLib: in CarbonLib 1.0 and later
3894 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3895 }
3896 procedure PBGetForkSizeAsync( var paramBlock: FSForkIOParam ); external name '_PBGetForkSizeAsync';
3897 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3898
3899
3900 {
3901 SetForkSize
3902 Set the logical size (end-of-file) of an open fork. This
3903 may cause space to be allocated or deallocated.
3904 -> ioCompletion A pointer to a completion routine
3905 <- ioResult The result code of the function
3906 -> forkRefNum The reference number of the fork
3907 -> positionMode The base location for the new size
3908 -> positionOffset The offset of the new size from the base
3909 }
3910 {
3911 * FSSetForkSize()
3912 *
3913 * Mac OS X threading:
3914 * Thread safe since version 10.0
3915 *
3916 * Availability:
3917 * Mac OS X: in version 10.0 and later in CoreServices.framework
3918 * CarbonLib: in CarbonLib 1.0 and later
3919 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3920 }
FSSetForkSizenull3921 function FSSetForkSize( forkRefNum: FSIORefNum; positionMode: UInt16; positionOffset: SInt64 ): OSErr; external name '_FSSetForkSize';
3922 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3923
3924
3925 {
3926 * PBSetForkSizeSync()
3927 *
3928 * Mac OS X threading:
3929 * Thread safe since version 10.0
3930 *
3931 * Availability:
3932 * Mac OS X: in version 10.0 and later in CoreServices.framework
3933 * CarbonLib: in CarbonLib 1.0 and later
3934 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3935 }
PBSetForkSizeSyncnull3936 function PBSetForkSizeSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBSetForkSizeSync';
3937 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3938
3939
3940 {
3941 * PBSetForkSizeAsync()
3942 *
3943 * Mac OS X threading:
3944 * Thread safe since version 10.0
3945 *
3946 * Availability:
3947 * Mac OS X: in version 10.0 and later in CoreServices.framework
3948 * CarbonLib: in CarbonLib 1.0 and later
3949 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3950 }
3951 procedure PBSetForkSizeAsync( var paramBlock: FSForkIOParam ); external name '_PBSetForkSizeAsync';
3952 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3953
3954
3955 {
3956 AllocateFork
3957 Allocate space to an open fork. Typically, the space to be
3958 allocated is beyond the current size of the fork, to reserve
3959 space so the file will be able to grow later. Some volume
3960 formats are unable to allocate space beyond the logical size
3961 of the fork.
3962 -> ioCompletion A pointer to a completion routine
3963 <- ioResult The result code of the function
3964 -> forkRefNum The reference number of the fork
3965 -> positionMode The base location for start of allocation
3966 -> positionOffset The offset of the start of allocation
3967 -> allocationFlags Zero or more of the following flags:
3968 kFSAllocContiguousMask
3969 Any newly allocated space must be one contiguous piece.
3970 kFSAllocAllOrNothingMask
3971 All of the request space must be available, or the call
3972 will fail. (If not set, the call may succeed even though
3973 some of the requested space wasn't allocated.)
3974 kFSAllocNoRoundUpMask
3975 Do not allocate additional space. (If not set, a volume
3976 may allocate additional space in order to reduce fragmentation.)
3977 <> allocationAmount The number of bytes to allocate
3978 On output, the number of bytes actually added
3979 }
3980 {
3981 * FSAllocateFork()
3982 *
3983 * Mac OS X threading:
3984 * Thread safe since version 10.0
3985 *
3986 * Availability:
3987 * Mac OS X: in version 10.0 and later in CoreServices.framework
3988 * CarbonLib: in CarbonLib 1.0 and later
3989 * Non-Carbon CFM: in InterfaceLib 9.0 and later
3990 }
FSAllocateForknull3991 function FSAllocateFork( forkRefNum: FSIORefNum; flags: FSAllocationFlags; positionMode: UInt16; positionOffset: SInt64; requestCount: UInt64; actualCount: UInt64Ptr ): OSErr; external name '_FSAllocateFork';
3992 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
3993
3994
3995 {
3996 * PBAllocateForkSync()
3997 *
3998 * Mac OS X threading:
3999 * Thread safe since version 10.0
4000 *
4001 * Availability:
4002 * Mac OS X: in version 10.0 and later in CoreServices.framework
4003 * CarbonLib: in CarbonLib 1.0 and later
4004 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4005 }
PBAllocateForkSyncnull4006 function PBAllocateForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBAllocateForkSync';
4007 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4008
4009
4010 {
4011 * PBAllocateForkAsync()
4012 *
4013 * Mac OS X threading:
4014 * Thread safe since version 10.0
4015 *
4016 * Availability:
4017 * Mac OS X: in version 10.0 and later in CoreServices.framework
4018 * CarbonLib: in CarbonLib 1.0 and later
4019 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4020 }
4021 procedure PBAllocateForkAsync( var paramBlock: FSForkIOParam ); external name '_PBAllocateForkAsync';
4022 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4023
4024
4025 {
4026 FlushFork
4027 Flush a fork. Any data written to this fork refnum is flushed to the device.
4028 The volume's control structures are also flushed to the device.
4029 -> ioCompletion A pointer to a completion routine
4030 <- ioResult The result code of the function
4031 -> forkRefNum The reference number of the fork to flush
4032 }
4033 {
4034 * FSFlushFork()
4035 *
4036 * Mac OS X threading:
4037 * Thread safe since version 10.0
4038 *
4039 * Availability:
4040 * Mac OS X: in version 10.0 and later in CoreServices.framework
4041 * CarbonLib: in CarbonLib 1.0 and later
4042 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4043 }
FSFlushForknull4044 function FSFlushFork( forkRefNum: FSIORefNum ): OSErr; external name '_FSFlushFork';
4045 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4046
4047
4048 {
4049 * PBFlushForkSync()
4050 *
4051 * Mac OS X threading:
4052 * Thread safe since version 10.0
4053 *
4054 * Availability:
4055 * Mac OS X: in version 10.0 and later in CoreServices.framework
4056 * CarbonLib: in CarbonLib 1.0 and later
4057 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4058 }
PBFlushForkSyncnull4059 function PBFlushForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBFlushForkSync';
4060 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4061
4062
4063 {
4064 * PBFlushForkAsync()
4065 *
4066 * Mac OS X threading:
4067 * Thread safe since version 10.0
4068 *
4069 * Availability:
4070 * Mac OS X: in version 10.0 and later in CoreServices.framework
4071 * CarbonLib: in CarbonLib 1.0 and later
4072 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4073 }
4074 procedure PBFlushForkAsync( var paramBlock: FSForkIOParam ); external name '_PBFlushForkAsync';
4075 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4076
4077
4078 {
4079 CloseFork
4080 Flush and close a fork. Any data written to this fork refnum is flushed
4081 to the device. The volume's control structures are also flushed to the device.
4082 -> ioCompletion A pointer to a completion routine
4083 <- ioResult The result code of the function
4084 -> forkRefNum The reference number of the fork to close
4085 }
4086 {
4087 * FSCloseFork()
4088 *
4089 * Mac OS X threading:
4090 * Thread safe since version 10.0
4091 *
4092 * Availability:
4093 * Mac OS X: in version 10.0 and later in CoreServices.framework
4094 * CarbonLib: in CarbonLib 1.0 and later
4095 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4096 }
FSCloseForknull4097 function FSCloseFork( forkRefNum: FSIORefNum ): OSErr; external name '_FSCloseFork';
4098 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4099
4100
4101 {
4102 * PBCloseForkSync()
4103 *
4104 * Mac OS X threading:
4105 * Thread safe since version 10.0
4106 *
4107 * Availability:
4108 * Mac OS X: in version 10.0 and later in CoreServices.framework
4109 * CarbonLib: in CarbonLib 1.0 and later
4110 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4111 }
PBCloseForkSyncnull4112 function PBCloseForkSync( var paramBlock: FSForkIOParam ): OSErr; external name '_PBCloseForkSync';
4113 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4114
4115
4116 {
4117 * PBCloseForkAsync()
4118 *
4119 * Mac OS X threading:
4120 * Thread safe since version 10.0
4121 *
4122 * Availability:
4123 * Mac OS X: in version 10.0 and later in CoreServices.framework
4124 * CarbonLib: in CarbonLib 1.0 and later
4125 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4126 }
4127 procedure PBCloseForkAsync( var paramBlock: FSForkIOParam ); external name '_PBCloseForkAsync';
4128 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4129
4130
4131 {
4132 GetForkCBInfo
4133 Return information about an open fork.
4134 -> ioCompletion A pointer to a completion routine
4135 <- ioResult The result code of the function
4136 <> desiredRefNum If non-zero on input, then get information for this refnum;
4137 unchanged on output. If zero on input, iterate over all open
4138 forks (possibly limited to a single volume); on output, contains
4139 the fork's refnum.
4140 -> volumeRefNum Used when desiredRefNum is zero on input. Set to 0 to iterate over all
4141 volumes, or set to a FSVolumeRefNum to limit iteration to that volume.
4142 <> iterator Used when desiredRefNum is zero on input. Set to 0 before iterating.
4143 Pass the iterator returned by the previous call to continue iterating.
4144 <- actualRefNum The refnum of the open fork.
4145 <- ref The FSRef for the file or directory that contains the fork.
4146 <- forkInfo Various information about the open fork.
4147 <- outForkName The name of the fork
4148 Note: the foundRefNum, ref, forkInfo, and fork name outputs are all optional; if you don't want
4149 a particular output, then set its pointer to NULL. If forkName is NULL, then forkNameLength
4150 will be undefined.
4151 Note: Returning the forkInfo generally does not require a disk access. Returning the
4152 ref or forkName may cause disk access for some volume formats.
4153 }
4154 {
4155 * FSGetForkCBInfo()
4156 *
4157 * Mac OS X threading:
4158 * Thread safe since version 10.0
4159 *
4160 * Availability:
4161 * Mac OS X: in version 10.0 and later in CoreServices.framework
4162 * CarbonLib: in CarbonLib 1.0 and later
4163 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4164 }
FSGetForkCBInfonull4165 function FSGetForkCBInfo( desiredRefNum: FSIORefNum; volume: FSVolumeRefNum; iterator: SInt16Ptr; actualRefNum: SInt16Ptr; forkInfo: FSForkInfoPtr; ref: FSRefPtr; outForkName: HFSUniStr255Ptr ): OSErr; external name '_FSGetForkCBInfo';
4166 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4167
4168
4169 {
4170 * PBGetForkCBInfoSync()
4171 *
4172 * Mac OS X threading:
4173 * Thread safe since version 10.0
4174 *
4175 * Availability:
4176 * Mac OS X: in version 10.0 and later in CoreServices.framework
4177 * CarbonLib: in CarbonLib 1.0 and later
4178 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4179 }
PBGetForkCBInfoSyncnull4180 function PBGetForkCBInfoSync( var paramBlock: FSForkCBInfoParam ): OSErr; external name '_PBGetForkCBInfoSync';
4181 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4182
4183
4184 {
4185 * PBGetForkCBInfoAsync()
4186 *
4187 * Mac OS X threading:
4188 * Thread safe since version 10.0
4189 *
4190 * Availability:
4191 * Mac OS X: in version 10.0 and later in CoreServices.framework
4192 * CarbonLib: in CarbonLib 1.0 and later
4193 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4194 }
4195 procedure PBGetForkCBInfoAsync( var paramBlock: FSForkCBInfoParam ); external name '_PBGetForkCBInfoAsync';
4196 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4197
4198
4199 {
4200 PBXLockRange
4201 Lock a range of bytes of the file fork specified by forkRefNum.
4202 This is only supported on some volume formats.
4203 -> ioCompletion A pointer to a completion routine
4204 <- ioResult The result code of the function
4205 -> forkRefNum The reference number of the fork to read from
4206 -> requestCount The number of bytes to lock
4207 -> positionMode The base location for start of the range
4208 -> positionOffset The offset from base location for start of the range
4209 <- rangeStart Number of the first byte locked
4210 }
4211 {
4212 * FSLockRange()
4213 *
4214 * Mac OS X threading:
4215 * Thread safe since version 10.4
4216 *
4217 * Availability:
4218 * Mac OS X: in version 10.4 and later in CoreServices.framework
4219 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4220 * Non-Carbon CFM: not available
4221 }
FSLockRangenull4222 function FSLockRange( forkRefNum: FSIORefNum; positionMode: UInt16; positionOffset: SInt64; requestCount: UInt64; var rangeStart: UInt64 ): OSStatus; external name '_FSLockRange';
4223 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4224
4225
4226 {
4227 * PBXLockRangeSync()
4228 *
4229 * Mac OS X threading:
4230 * Thread safe since version 10.4
4231 *
4232 * Availability:
4233 * Mac OS X: in version 10.4 and later in CoreServices.framework
4234 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4235 * Non-Carbon CFM: not available
4236 }
PBXLockRangeSyncnull4237 function PBXLockRangeSync( paramBlock: FSRangeLockParamPtr ): OSStatus; external name '_PBXLockRangeSync';
4238 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4239
4240
4241 {
4242 * PBXLockRangeAsync()
4243 *
4244 * Mac OS X threading:
4245 * Thread safe since version 10.4
4246 *
4247 * Availability:
4248 * Mac OS X: in version 10.4 and later in CoreServices.framework
4249 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4250 * Non-Carbon CFM: not available
4251 }
PBXLockRangeAsyncnull4252 function PBXLockRangeAsync( paramBlock: FSRangeLockParamPtr ): OSStatus; external name '_PBXLockRangeAsync';
4253 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4254
4255
4256 {
4257 PBXUnlockRange
4258 Unlock a range of bytes of the file fork specified by forkRefNum.
4259 This is only supported on some volume formats.
4260 -> ioCompletion A pointer to a completion routine
4261 <- ioResult The result code of the function
4262 -> forkRefNum The reference number of the fork to read from
4263 -> requestCount The number of bytes to lock
4264 -> positionMode The base location for start of the range
4265 -> positionOffset The offset from base location for start of the range
4266 <- rangeStart Number of the first byte unlocked
4267 }
4268 {
4269 * FSUnlockRange()
4270 *
4271 * Mac OS X threading:
4272 * Thread safe since version 10.4
4273 *
4274 * Availability:
4275 * Mac OS X: in version 10.4 and later in CoreServices.framework
4276 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4277 * Non-Carbon CFM: not available
4278 }
FSUnlockRangenull4279 function FSUnlockRange( forkRefNum: FSIORefNum; positionMode: UInt16; positionOffset: SInt64; requestCount: UInt64; var rangeStart: UInt64 ): OSStatus; external name '_FSUnlockRange';
4280 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4281
4282
4283 {
4284 * PBXUnlockRangeSync()
4285 *
4286 * Mac OS X threading:
4287 * Thread safe since version 10.4
4288 *
4289 * Availability:
4290 * Mac OS X: in version 10.4 and later in CoreServices.framework
4291 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4292 * Non-Carbon CFM: not available
4293 }
PBXUnlockRangeSyncnull4294 function PBXUnlockRangeSync( paramBlock: FSRangeLockParamPtr ): OSStatus; external name '_PBXUnlockRangeSync';
4295 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4296
4297
4298 {
4299 * PBXUnlockRangeAsync()
4300 *
4301 * Mac OS X threading:
4302 * Thread safe since version 10.4
4303 *
4304 * Availability:
4305 * Mac OS X: in version 10.4 and later in CoreServices.framework
4306 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4307 * Non-Carbon CFM: not available
4308 }
PBXUnlockRangeAsyncnull4309 function PBXUnlockRangeAsync( paramBlock: FSRangeLockParamPtr ): OSStatus; external name '_PBXUnlockRangeAsync';
4310 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4311
4312
4313 {
4314 GetVolumeInfo
4315 Returns various information about a given volume, or indexing over all volumes.
4316 -> ioCompletion A pointer to a completion routine
4317 <- ioResult The result code of the function
4318 <> ioVRefNum On input, the volume reference number or drive number whose
4319 information is to be returned (if volumeIndex is 0); same
4320 as "volume" input to FSGetVolumeInfo.
4321 On output, the actual volume reference number; same as
4322 "actualVolume" output of FSGetVolumeInfo.
4323 -> volumeIndex The index of the desired volume, or 0 to use ioVRefNum
4324 -> whichInfo Which volInfo info fields to get
4325 <- volumeInfo The returned values of Volume info fields; may be NULL
4326 <- name The Unicode name is returned here. This pointer may be NULL.
4327 Note: All of the outputs are optional; if you don't want that particular output, just
4328 set its pointer to NULL.
4329 }
4330 {
4331 * FSGetVolumeInfo()
4332 *
4333 * Mac OS X threading:
4334 * Thread safe since version 10.0
4335 *
4336 * Availability:
4337 * Mac OS X: in version 10.0 and later in CoreServices.framework
4338 * CarbonLib: in CarbonLib 1.0 and later
4339 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4340 }
FSGetVolumeInfonull4341 function FSGetVolumeInfo( volume: FSVolumeRefNum; volumeIndex: ItemCount; actualVolume: FSVolumeRefNumPtr; whichInfo: FSVolumeInfoBitmap; info: FSVolumeInfoPtr; volumeName: HFSUniStr255Ptr; rootDirectory: FSRefPtr ): OSErr; external name '_FSGetVolumeInfo';
4342 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4343
4344
4345 {
4346 * PBGetVolumeInfoSync()
4347 *
4348 * Mac OS X threading:
4349 * Thread safe since version 10.0
4350 *
4351 * Availability:
4352 * Mac OS X: in version 10.0 and later in CoreServices.framework
4353 * CarbonLib: in CarbonLib 1.0 and later
4354 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4355 }
PBGetVolumeInfoSyncnull4356 function PBGetVolumeInfoSync( var paramBlock: FSVolumeInfoParam ): OSErr; external name '_PBGetVolumeInfoSync';
4357 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4358
4359
4360 {
4361 * PBGetVolumeInfoAsync()
4362 *
4363 * Mac OS X threading:
4364 * Thread safe since version 10.0
4365 *
4366 * Availability:
4367 * Mac OS X: in version 10.0 and later in CoreServices.framework
4368 * CarbonLib: in CarbonLib 1.0 and later
4369 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4370 }
4371 procedure PBGetVolumeInfoAsync( var paramBlock: FSVolumeInfoParam ); external name '_PBGetVolumeInfoAsync';
4372 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4373
4374
4375 {
4376 SetVolumeInfo
4377 Set information about a given volume.
4378 -> ioCompletion A pointer to a completion routine
4379 <- ioResult The result code of the function
4380 -> ioVRefNum The volume whose information is to be changed
4381 -> whichInfo Which catalog info fields to set
4382 -> volumeInfo The new values of volume info fields
4383 Note: Only some of the volume info fields may be set. The settable fields
4384 are given by the constant kFSVolInfoSettableInfo; no other bits may be set in
4385 whichInfo.
4386 }
4387 {
4388 * FSSetVolumeInfo()
4389 *
4390 * Mac OS X threading:
4391 * Thread safe since version 10.0
4392 *
4393 * Availability:
4394 * Mac OS X: in version 10.0 and later in CoreServices.framework
4395 * CarbonLib: in CarbonLib 1.0 and later
4396 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4397 }
FSSetVolumeInfonull4398 function FSSetVolumeInfo( volume: FSVolumeRefNum; whichInfo: FSVolumeInfoBitmap; const (*var*) info: FSVolumeInfo ): OSErr; external name '_FSSetVolumeInfo';
4399 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4400
4401
4402 {
4403 * PBSetVolumeInfoSync()
4404 *
4405 * Mac OS X threading:
4406 * Thread safe since version 10.0
4407 *
4408 * Availability:
4409 * Mac OS X: in version 10.0 and later in CoreServices.framework
4410 * CarbonLib: in CarbonLib 1.0 and later
4411 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4412 }
PBSetVolumeInfoSyncnull4413 function PBSetVolumeInfoSync( var paramBlock: FSVolumeInfoParam ): OSErr; external name '_PBSetVolumeInfoSync';
4414 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4415
4416
4417 {
4418 * PBSetVolumeInfoAsync()
4419 *
4420 * Mac OS X threading:
4421 * Thread safe since version 10.0
4422 *
4423 * Availability:
4424 * Mac OS X: in version 10.0 and later in CoreServices.framework
4425 * CarbonLib: in CarbonLib 1.0 and later
4426 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4427 }
4428 procedure PBSetVolumeInfoAsync( var paramBlock: FSVolumeInfoParam ); external name '_PBSetVolumeInfoAsync';
4429 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4430
4431
4432 {
4433 FSGetDataForkName
4434 Returns the constant for the name of the data fork (the empty string)
4435 }
4436 {
4437 * FSGetDataForkName()
4438 *
4439 * Mac OS X threading:
4440 * Thread safe since version 10.0
4441 *
4442 * Availability:
4443 * Mac OS X: in version 10.0 and later in CoreServices.framework
4444 * CarbonLib: in CarbonLib 1.0 and later
4445 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4446 }
FSGetDataForkNamenull4447 function FSGetDataForkName( var dataForkName: HFSUniStr255 ): OSErr; external name '_FSGetDataForkName';
4448 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4449
4450
4451 {
4452 FSGetResourceForkName
4453 Returns the constant for the name of the resource fork
4454 (currently "RESOURCE_FORK").
4455 }
4456 {
4457 * FSGetResourceForkName()
4458 *
4459 * Mac OS X threading:
4460 * Thread safe since version 10.0
4461 *
4462 * Availability:
4463 * Mac OS X: in version 10.0 and later in CoreServices.framework
4464 * CarbonLib: in CarbonLib 1.0 and later
4465 * Non-Carbon CFM: in InterfaceLib 9.0 and later
4466 }
FSGetResourceForkNamenull4467 function FSGetResourceForkName( var resourceForkName: HFSUniStr255 ): OSErr; external name '_FSGetResourceForkName';
4468 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4469
4470
4471 {
4472 * FSRefMakePath()
4473 *
4474 * Summary:
4475 * converts an FSRef to a POSIX path
4476 *
4477 * Mac OS X threading:
4478 * Thread safe since version 10.0
4479 *
4480 * Parameters:
4481 *
4482 * ref:
4483 * the file/dir to get the POSIX path for
4484 *
4485 * path:
4486 * a pointer to a buffer which FSRefMakePath will fill with a UTF8
4487 * encoded C string representing the path the the specified FSRef
4488 *
4489 * pathBufferSize:
4490 * the size of the path buffer in bytes. This size should include
4491 * the NULL terminator for the returned path string.
4492 *
4493 * Availability:
4494 * Mac OS X: in version 10.0 and later in CoreServices.framework
4495 * CarbonLib: in CarbonLib 1.1 and later
4496 * Non-Carbon CFM: not available
4497 }
FSRefMakePathnull4498 function FSRefMakePath( const (*var*) ref: FSRef; path: CStringPtr; pathBufferSize: UInt32 ): OSStatus; external name '_FSRefMakePath';
4499 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4500
4501
4502 {
4503 * FSPathMakeRef()
4504 *
4505 * Summary:
4506 * converts a POSIX path to an FSRef
4507 *
4508 * Mac OS X threading:
4509 * Thread safe since version 10.0
4510 *
4511 * Parameters:
4512 *
4513 * path:
4514 * a pointer to a UTF8 encoded C String that is a POSIX path
4515 *
4516 * ref:
4517 * a pointer to an FSRef to fill in
4518 *
4519 * isDirectory:
4520 * an optional pointer to a Boolean that will be filled in with
4521 * whether the specified path is a directory (vs. a file)
4522 *
4523 * Availability:
4524 * Mac OS X: in version 10.0 and later in CoreServices.framework
4525 * CarbonLib: in CarbonLib 1.1 and later
4526 * Non-Carbon CFM: not available
4527 }
FSPathMakeRefnull4528 function FSPathMakeRef( path: CStringPtr; var ref: FSRef; isDirectory: BooleanPtr ): OSStatus; external name '_FSPathMakeRef';
4529 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4530
4531
4532 {
4533 * FSPathMakeRefOptions
4534 *
4535 * Discussion:
4536 * Options that can be passed to the FSPathMakeRefWithOptions call.
4537 }
4538 const
4539 kFSPathMakeRefDefaultOptions = 0;
4540 kFSPathMakeRefDoNotFollowLeafSymlink = $01;
4541
4542 {
4543 * FSPathMakeRefWithOptions()
4544 *
4545 * Summary:
4546 * converts a POSIX path to an FSRef allowing for options other than
4547 * the default
4548 *
4549 * Mac OS X threading:
4550 * Thread safe since version 10.4
4551 *
4552 * Parameters:
4553 *
4554 * path:
4555 * a pointer to a UTF8 encoded C String that is a POSIX path
4556 *
4557 * options:
4558 * a set of FSPathMakeRef options
4559 *
4560 * ref:
4561 * a pointer to an FSRef to fill in
4562 *
4563 * isDirectory:
4564 * an optional pointer to a Boolean that will be filled in with
4565 * whether the specified path is a directory (vs. a file)
4566 *
4567 * Availability:
4568 * Mac OS X: in version 10.4 and later in CoreServices.framework
4569 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4570 * Non-Carbon CFM: not available
4571 }
FSPathMakeRefWithOptionsnull4572 function FSPathMakeRefWithOptions( path: CStringPtr; options: OptionBits; var ref: FSRef; isDirectory: BooleanPtr ): OSStatus; external name '_FSPathMakeRefWithOptions';
4573 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4574
4575
4576 {
4577 * FSIsFSRefValid()
4578 *
4579 * Summary:
4580 * Returns true if ref refers to an existing valid file system
4581 * object, false otherwise.
4582 *
4583 * Mac OS X threading:
4584 * Thread safe since version 10.4
4585 *
4586 * Parameters:
4587 *
4588 * ref:
4589 * FSRef to test
4590 *
4591 * Availability:
4592 * Mac OS X: in version 10.4 and later in CoreServices.framework
4593 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.4 and later
4594 * Non-Carbon CFM: not available
4595 }
FSIsFSRefValidnull4596 function FSIsFSRefValid( const (*var*) ref: FSRef ): Boolean; external name '_FSIsFSRefValid';
4597 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4598
4599
4600 {
4601 * FNMessage
4602 *
4603 * Discussion:
4604 * Messages broadcast about a directory. If system clients (such as
4605 * the Finder) are interested in changes to a directory, they will
4606 * receive notifications when application code broadcasts change
4607 * messages about that directory.
4608 }
4609 type
4610 FNMessage = UInt32;
4611 const
4612 kFNDirectoryModifiedMessage = 1;
4613
4614 {
4615 * FNNotify()
4616 *
4617 * Summary:
4618 * Broadcasts notification of changes to the specified directory.
4619 *
4620 * Discussion:
4621 * FNNotify is used to notify system clients (such as the Finder) of
4622 * modifications to the contents of a directory, specifically
4623 * addition or removal of files or folders from the directory. The
4624 * Finder and other system clients will refresh their views of the
4625 * specified directory when they receive the change notification.
4626 * FNNotify is not meant to notify the Finder of changes to a
4627 * specific file (for example, changes to a file's type or creator);
4628 * for that purpose, use a kAESync AppleEvent sent to the Finder.
4629 *
4630 * Mac OS X threading:
4631 * Thread safe since version 10.0
4632 *
4633 * Parameters:
4634 *
4635 * ref:
4636 * The directory for which to broadcast the notification
4637 *
4638 * message:
4639 * An indication of what happened to the target directory
4640 *
4641 * flags:
4642 * Options about delivery of the notification (specify kNilOptions
4643 * for default behaviour)
4644 *
4645 * Availability:
4646 * Mac OS X: in version 10.0 and later in CoreServices.framework
4647 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.0 and later
4648 * Non-Carbon CFM: not available
4649 }
FNNotifynull4650 function FNNotify( const (*var*) ref: FSRef; message: FNMessage; flags: OptionBits ): OSStatus; external name '_FNNotify';
4651 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4652
4653
4654 {
4655 * FNNotifyByPath()
4656 *
4657 * Summary:
4658 * Broadcasts notification of changes to the specified directory.
4659 *
4660 * Mac OS X threading:
4661 * Thread safe since version 10.0
4662 *
4663 * Parameters:
4664 *
4665 * path:
4666 * Path to the directory for which to broadcast the notification
4667 *
4668 * message:
4669 * An indication of what happened to the target directory
4670 *
4671 * flags:
4672 * Options about delivery of the notification (specify kNilOptions
4673 * for default behaviour)
4674 *
4675 * Availability:
4676 * Mac OS X: in version 10.0 and later in CoreServices.framework
4677 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.0 and later
4678 * Non-Carbon CFM: not available
4679 }
FNNotifyByPathnull4680 function FNNotifyByPath( path: CStringPtr; message: FNMessage; flags: OptionBits ): OSStatus; external name '_FNNotifyByPath';
4681 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4682
4683
4684 {
4685 * FNNotifyAll()
4686 *
4687 * Discussion:
4688 * Broadcasts notification of changes to the filesystem (should only
4689 * be used by installers or programs which make lots of changes and
4690 * only send one broadcast).
4691 *
4692 * Mac OS X threading:
4693 * Thread safe since version 10.0
4694 *
4695 * Parameters:
4696 *
4697 * message:
4698 * An indication of what happened
4699 *
4700 * flags:
4701 * Options about delivery of the notification (specify kNilOptions
4702 * for default behaviour)
4703 *
4704 * Availability:
4705 * Mac OS X: in version 10.0 and later in CoreServices.framework
4706 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.0 and later
4707 * Non-Carbon CFM: not available
4708 }
FNNotifyAllnull4709 function FNNotifyAll( message: FNMessage; flags: OptionBits ): OSStatus; external name '_FNNotifyAll';
4710 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4711
4712
4713 {
4714 * FNSubscriptionRef
4715 *
4716 * Discussion:
4717 * A token associated with a notification subscription. The
4718 * subscriber gets one back when they subscribe to notifications for
4719 * a particular directory, and they supply it when the unsubscribe.
4720 * It is also delivered along with the notifications for that
4721 * subscription.
4722 }
4723 type
4724 FNSubscriptionRef = ^OpaqueFNSubscriptionRef; { an opaque type }
4725 OpaqueFNSubscriptionRef = record end;
4726 FNSubscriptionRefPtr = ^FNSubscriptionRef; { when a var xx:FNSubscriptionRef parameter can be nil, it is changed to xx: FNSubscriptionRefPtr }
4727
4728 {
4729 * Discussion:
4730 * Options that can be specified at subscription time.
4731 }
4732 const
4733 {
4734 * Specify this option if you do not want to receive notifications on
4735 * this subscription when FNNotifyAll is called; by default any
4736 * subscription is also implicitly a subscription to wildcard
4737 * notifications
4738 }
4739 kFNNoImplicitAllSubscription = 1 shl 0;
4740
4741 {
4742 * Specify this option if you want to receive notifications on this
4743 * subscription when your application is in background. By default
4744 * notifications will be coalesced and and delivered when your
4745 * application becomes foreground.
4746 }
4747 kFNNotifyInBackground = 1 shl 1;
4748
4749
4750 {
4751 * FNSubscriptionProcPtr
4752 *
4753 * Discussion:
4754 * Callback delivered for directory notifications.
4755 *
4756 * Parameters:
4757 *
4758 * message:
4759 * An indication of what happened
4760 *
4761 * flags:
4762 * Options about delivery of the notification (typically
4763 * kNilOptions)
4764 *
4765 * refcon:
4766 * User reference supplied with subscription
4767 *
4768 * subscription:
4769 * Subscription corresponding to this notification
4770 }
4771 type
4772 FNSubscriptionProcPtr = procedure( message: FNMessage; flags: OptionBits; refcon: UnivPtr; subscription: FNSubscriptionRef );
4773
4774 FNSubscriptionUPP = FNSubscriptionProcPtr;
4775 {
4776 * NewFNSubscriptionUPP()
4777 *
4778 * Availability:
4779 * Mac OS X: in version 10.1 and later in CoreServices.framework
4780 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4781 * Non-Carbon CFM: available as macro/inline
4782 }
NewFNSubscriptionUPPnull4783 function NewFNSubscriptionUPP( userRoutine: FNSubscriptionProcPtr ): FNSubscriptionUPP; external name '_NewFNSubscriptionUPP';
4784 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4785
4786 {
4787 * DisposeFNSubscriptionUPP()
4788 *
4789 * Availability:
4790 * Mac OS X: in version 10.1 and later in CoreServices.framework
4791 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4792 * Non-Carbon CFM: available as macro/inline
4793 }
4794 procedure DisposeFNSubscriptionUPP( userUPP: FNSubscriptionUPP ); external name '_DisposeFNSubscriptionUPP';
4795 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4796
4797 {
4798 * InvokeFNSubscriptionUPP()
4799 *
4800 * Availability:
4801 * Mac OS X: in version 10.1 and later in CoreServices.framework
4802 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4803 * Non-Carbon CFM: available as macro/inline
4804 }
4805 procedure InvokeFNSubscriptionUPP( message: FNMessage; flags: OptionBits; refcon: UnivPtr; subscription: FNSubscriptionRef; userUPP: FNSubscriptionUPP ); external name '_InvokeFNSubscriptionUPP';
4806 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4807
4808 {#if __MACH__
4809 #define NewFNSubscriptionUPP(userRoutine) ((FNSubscriptionUPP)userRoutine)
4810 #define DisposeFNSubscriptionUPP(userUPP)
4811 #define InvokeFNSubscriptionUPP(message, flags, refcon, subscription, userUPP) (*userUPP)(message, flags, refcon, subscription)
4812 #endif}
4813
4814 {
4815 * FNSubscribe()
4816 *
4817 * Summary:
4818 * Subscribe to change notifications for the specified directory.
4819 *
4820 * Mac OS X threading:
4821 * Thread safe since version 10.1
4822 *
4823 * Parameters:
4824 *
4825 * directoryRef:
4826 * Directory for which the caller wants notifications
4827 *
4828 * callback:
4829 * Function to call back when a notification arrives
4830 *
4831 * refcon:
4832 * User state carried with the subscription
4833 *
4834 * flags:
4835 * Options for future use (specify kNilOptions, or one of the
4836 * FNSubscriptionOptions)
4837 *
4838 * subscription:
4839 * Subscription token for subsequent query or unsubscription
4840 *
4841 * Availability:
4842 * Mac OS X: in version 10.1 and later in CoreServices.framework
4843 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4844 * Non-Carbon CFM: not available
4845 }
FNSubscribenull4846 function FNSubscribe( const (*var*) directoryRef: FSRef; callback: FNSubscriptionUPP; refcon: UnivPtr; flags: OptionBits; var subscription: FNSubscriptionRef ): OSStatus; external name '_FNSubscribe';
4847 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4848
4849
4850 {
4851 * FNSubscribeByPath()
4852 *
4853 * Summary:
4854 * Subscribe to change notifications for the specified directory.
4855 *
4856 * Mac OS X threading:
4857 * Thread safe since version 10.1
4858 *
4859 * Parameters:
4860 *
4861 * directoryPath:
4862 * Directory for which the caller wants notifications
4863 *
4864 * callback:
4865 * Function to call back when a notification arrives
4866 *
4867 * refcon:
4868 * User state carried with the subscription
4869 *
4870 * flags:
4871 * Options for future use (specify kNilOptions, or one of the
4872 * FNSubscriptionOptions)
4873 *
4874 * subscription:
4875 * Subscription token for subsequent query or unsubscription
4876 *
4877 * Availability:
4878 * Mac OS X: in version 10.1 and later in CoreServices.framework
4879 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4880 * Non-Carbon CFM: not available
4881 }
4882 function FNSubscribeByPath( directoryPath: CStringPtr; callback: FNSubscriptionUPP; refcon: UnivPtr; flags: OptionBits; var subscription: FNSubscriptionRef ): OSStatus; external name '_FNSubscribeByPath';
4883 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4884
4885
4886 {
4887 * FNUnsubscribe()
4888 *
4889 * Summary:
4890 * Release a subscription which is no longer needed.
4891 *
4892 * Mac OS X threading:
4893 * Thread safe since version 10.1
4894 *
4895 * Parameters:
4896 *
4897 * subscription:
4898 * Subscription previously returned from FNSubscribe or
4899 * FNSubscribeForPath
4900 *
4901 * Availability:
4902 * Mac OS X: in version 10.1 and later in CoreServices.framework
4903 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4904 * Non-Carbon CFM: not available
4905 }
FNUnsubscribenull4906 function FNUnsubscribe( subscription: FNSubscriptionRef ): OSStatus; external name '_FNUnsubscribe';
4907 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4908
4909
4910 {
4911 * FNGetDirectoryForSubscription()
4912 *
4913 * Summary:
4914 * Fetch the directory for which this subscription was originally
4915 * entered. There is no path variant because paths are fragile, and
4916 * the path may have changed. If the caller does not care about
4917 * this subtlety, she can call FSRefMakePath to get a path from the
4918 * returned ref.
4919 *
4920 * Mac OS X threading:
4921 * Thread safe since version 10.1
4922 *
4923 * Parameters:
4924 *
4925 * subscription:
4926 * Subscription previously returned from FNSubscribe or
4927 * FNSubscribeForPath
4928 *
4929 * ref:
4930 * Directory for which this subscription was created
4931 *
4932 * Availability:
4933 * Mac OS X: in version 10.1 and later in CoreServices.framework
4934 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.1 and later
4935 * Non-Carbon CFM: not available
4936 }
FNGetDirectoryForSubscriptionnull4937 function FNGetDirectoryForSubscription( subscription: FNSubscriptionRef; var ref: FSRef ): OSStatus; external name '_FNGetDirectoryForSubscription';
4938 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_1, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4939
4940
4941 { Async Volume Operation Status return values}
4942 const
4943 kAsyncMountInProgress = 1;
4944 kAsyncMountComplete = 2;
4945 kAsyncUnmountInProgress = 3;
4946 kAsyncUnmountComplete = 4;
4947 kAsyncEjectInProgress = 5;
4948 kAsyncEjectComplete = 6;
4949
4950
4951 type
4952 FSMountStatus = UInt32;
4953 FSEjectStatus = UInt32;
4954 FSUnmountStatus = UInt32;
4955 FSVolumeOperation = ^OpaqueFSVolumeOperation; { an opaque type }
4956 OpaqueFSVolumeOperation = record end;
4957 FSVolumeMountProcPtr = procedure( volumeOp: FSVolumeOperation; clientData: UnivPtr; err: OSStatus; mountedVolumeRefNum: FSVolumeRefNum );
4958 FSVolumeUnmountProcPtr = procedure( volumeOp: FSVolumeOperation; clientData: UnivPtr; err: OSStatus; volumeRefNum: FSVolumeRefNum; dissenter: pid_t );
4959 FSVolumeEjectProcPtr = procedure( volumeOp: FSVolumeOperation; clientData: UnivPtr; err: OSStatus; volumeRefNum: FSVolumeRefNum; dissenter: pid_t );
4960 FSVolumeMountUPP = FSVolumeMountProcPtr;
4961 FSVolumeUnmountUPP = FSVolumeUnmountProcPtr;
4962 FSVolumeEjectUPP = FSVolumeEjectProcPtr;
4963 {
4964 * NewFSVolumeMountUPP()
4965 *
4966 * Availability:
4967 * Mac OS X: in version 10.2 and later in CoreServices.framework
4968 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
4969 * Non-Carbon CFM: not available
4970 }
NewFSVolumeMountUPPnull4971 function NewFSVolumeMountUPP( userRoutine: FSVolumeMountProcPtr ): FSVolumeMountUPP; external name '_NewFSVolumeMountUPP';
4972 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4973
4974 {
4975 * NewFSVolumeUnmountUPP()
4976 *
4977 * Availability:
4978 * Mac OS X: in version 10.2 and later in CoreServices.framework
4979 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
4980 * Non-Carbon CFM: not available
4981 }
NewFSVolumeUnmountUPPnull4982 function NewFSVolumeUnmountUPP( userRoutine: FSVolumeUnmountProcPtr ): FSVolumeUnmountUPP; external name '_NewFSVolumeUnmountUPP';
4983 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4984
4985 {
4986 * NewFSVolumeEjectUPP()
4987 *
4988 * Availability:
4989 * Mac OS X: in version 10.2 and later in CoreServices.framework
4990 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
4991 * Non-Carbon CFM: not available
4992 }
NewFSVolumeEjectUPPnull4993 function NewFSVolumeEjectUPP( userRoutine: FSVolumeEjectProcPtr ): FSVolumeEjectUPP; external name '_NewFSVolumeEjectUPP';
4994 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
4995
4996 {
4997 * DisposeFSVolumeMountUPP()
4998 *
4999 * Availability:
5000 * Mac OS X: in version 10.2 and later in CoreServices.framework
5001 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
5002 * Non-Carbon CFM: not available
5003 }
5004 procedure DisposeFSVolumeMountUPP( userUPP: FSVolumeMountUPP ); external name '_DisposeFSVolumeMountUPP';
5005 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5006
5007 {
5008 * DisposeFSVolumeUnmountUPP()
5009 *
5010 * Availability:
5011 * Mac OS X: in version 10.2 and later in CoreServices.framework
5012 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
5013 * Non-Carbon CFM: not available
5014 }
5015 procedure DisposeFSVolumeUnmountUPP( userUPP: FSVolumeUnmountUPP ); external name '_DisposeFSVolumeUnmountUPP';
5016 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5017
5018 {
5019 * DisposeFSVolumeEjectUPP()
5020 *
5021 * Availability:
5022 * Mac OS X: in version 10.2 and later in CoreServices.framework
5023 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
5024 * Non-Carbon CFM: not available
5025 }
5026 procedure DisposeFSVolumeEjectUPP( userUPP: FSVolumeEjectUPP ); external name '_DisposeFSVolumeEjectUPP';
5027 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5028
5029 {
5030 * InvokeFSVolumeMountUPP()
5031 *
5032 * Availability:
5033 * Mac OS X: in version 10.2 and later in CoreServices.framework
5034 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
5035 * Non-Carbon CFM: not available
5036 }
5037 procedure InvokeFSVolumeMountUPP( volumeOp: FSVolumeOperation; clientData: UnivPtr; err: OSStatus; mountedVolumeRefNum: FSVolumeRefNum; userUPP: FSVolumeMountUPP ); external name '_InvokeFSVolumeMountUPP';
5038 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5039
5040 {
5041 * InvokeFSVolumeUnmountUPP()
5042 *
5043 * Availability:
5044 * Mac OS X: in version 10.2 and later in CoreServices.framework
5045 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
5046 * Non-Carbon CFM: not available
5047 }
5048 procedure InvokeFSVolumeUnmountUPP( volumeOp: FSVolumeOperation; clientData: UnivPtr; err: OSStatus; volumeRefNum: FSVolumeRefNum; dissenter: pid_t; userUPP: FSVolumeUnmountUPP ); external name '_InvokeFSVolumeUnmountUPP';
5049 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5050
5051 {
5052 * InvokeFSVolumeEjectUPP()
5053 *
5054 * Availability:
5055 * Mac OS X: in version 10.2 and later in CoreServices.framework
5056 * CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
5057 * Non-Carbon CFM: not available
5058 }
5059 procedure InvokeFSVolumeEjectUPP( volumeOp: FSVolumeOperation; clientData: UnivPtr; err: OSStatus; volumeRefNum: FSVolumeRefNum; dissenter: pid_t; userUPP: FSVolumeEjectUPP ); external name '_InvokeFSVolumeEjectUPP';
5060 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5061
5062 {#if __MACH__
5063 #define NewFSVolumeMountUPP(userRoutine) ((FSVolumeMountUPP)userRoutine)
5064 #define NewFSVolumeUnmountUPP(userRoutine) ((FSVolumeUnmountUPP)userRoutine)
5065 #define NewFSVolumeEjectUPP(userRoutine) ((FSVolumeEjectUPP)userRoutine)
5066 #define DisposeFSVolumeMountUPP(userUPP)
5067 #define DisposeFSVolumeUnmountUPP(userUPP)
5068 #define DisposeFSVolumeEjectUPP(userUPP)
5069 #define InvokeFSVolumeMountUPP(volumeOp, clientData, err, mountedVolumeRefNum, userUPP) (*userUPP)(volumeOp, clientData, err, mountedVolumeRefNum)
5070 #define InvokeFSVolumeUnmountUPP(volumeOp, clientData, err, volumeRefNum, dissenter, userUPP) (*userUPP)(volumeOp, clientData, err, volumeRefNum, dissenter)
5071 #define InvokeFSVolumeEjectUPP(volumeOp, clientData, err, volumeRefNum, dissenter, userUPP) (*userUPP)(volumeOp, clientData, err, volumeRefNum, dissenter)
5072 #endif}
5073
5074
5075 {
5076 * Discussion:
5077 * Options that can be passed to the FSMountServerVolumeCalls. These
5078 * options are not for use with the local volumes.
5079 }
5080 const
5081 {
5082 * Specify this option if you do want the volume displayed as a stand
5083 * along volume in the UI.
5084 }
5085 kFSMountServerMarkDoNotDisplay = 1 shl 0;
5086
5087 {
5088 * Specify this option if you want the volume mounted on the mountdir
5089 * passed in instead of in it.
5090 }
5091 kFSMountServerMountOnMountDir = 1 shl 2;
5092
5093 {
5094 * Specify this option if you want to suppress connection-time UI
5095 * when mounting the server volume.
5096 }
5097 kFSMountServerSuppressConnectionUI = 1 shl 6;
5098
5099
5100 {
5101 * Discussion:
5102 * Deprecated options that can be passed to
5103 * FSMountServerVolumeCalls. The options will have no effect on the
5104 * OS version they are noted as deprecated on or later.
5105 }
5106 const
5107 {
5108 * Specify this option if you do not want other processes notified
5109 * that this volume has been mounted. Deprecated on Mac OS X 10.5.
5110 * Use kFSMountServerMarkDoNotDisplay instead.
5111 }
5112 kFSMountServerMountWithoutNotification = 1 shl 1;
5113
5114
5115 {
5116 * Discussion:
5117 * Options that can be passed to the FSEjectVolume calls.
5118 }
5119 const
5120 {
5121 * Specify this option if you want the volume forcibly ejected.
5122 * Force ejecting a volume will very likely result in data loss since
5123 * the volume will be ejected even if there are open files on it or
5124 * other volumes that share the same device. This option should be
5125 * reserved for situations such as the backing store for a volume is
5126 * gone (so the data is lost regardless).
5127 }
5128 kFSEjectVolumeForceEject = 1 shl 0;
5129
5130
5131 {
5132 * Discussion:
5133 * Options that can be passed to the FSUnmountVolume calls.
5134 }
5135 const
5136 {
5137 * Specify this option if you want the volume forcibly unmounted.
5138 * Force unmounting a volume will very likely result in data loss
5139 * since the volume will be ejected even if there are open files on
5140 * it. This option should be reserved for situations such as the
5141 * backing store for a volume is gone (so the data is lost
5142 * regardless).
5143 }
5144 kFSUnmountVolumeForceUnmount = 1 shl 0;
5145
5146 {
5147 * FSCreateVolumeOperation()
5148 *
5149 * Discussion:
5150 * This routine will return an FSVolumeOperation which can be used
5151 * for an async volume operation. When the operation is completed
5152 * the volumeOp should be disposed of to free the memory associated
5153 * with the operation using FSDisposeVolumeOperation.
5154 *
5155 * Mac OS X threading:
5156 * Thread safe since version 10.2
5157 *
5158 * Parameters:
5159 *
5160 * volumeOp:
5161 * The new FSVolumeOperation.
5162 *
5163 * Availability:
5164 * Mac OS X: in version 10.2 and later in CoreServices.framework
5165 * CarbonLib: not available in CarbonLib 1.x
5166 * Non-Carbon CFM: not available
5167 }
FSCreateVolumeOperationnull5168 function FSCreateVolumeOperation( var volumeOp: FSVolumeOperation ): OSStatus; external name '_FSCreateVolumeOperation';
5169 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5170
5171
5172 {
5173 * FSDisposeVolumeOperation()
5174 *
5175 * Discussion:
5176 * This routine will release the memory associated with the passed
5177 * in volumeOp. It will return paramErr is the volumeOp is in use.
5178 *
5179 * Mac OS X threading:
5180 * Thread safe since version 10.2
5181 *
5182 * Parameters:
5183 *
5184 * volumeOp:
5185 * The FSVolumeOperation to release.
5186 *
5187 * Availability:
5188 * Mac OS X: in version 10.2 and later in CoreServices.framework
5189 * CarbonLib: not available in CarbonLib 1.x
5190 * Non-Carbon CFM: not available
5191 }
5192 function FSDisposeVolumeOperation( volumeOp: FSVolumeOperation ): OSStatus; external name '_FSDisposeVolumeOperation';
5193 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5194
5195
5196 {
5197 * FSMountLocalVolumeSync()
5198 *
5199 * Discussion:
5200 * This routine will mount the disk specified by diskID at mountDir
5201 * (or the default location if mountDir is NULL). This routine
5202 * returns after the mount is complete.
5203 *
5204 * Mac OS X threading:
5205 * Thread safe since version 10.2
5206 *
5207 * Parameters:
5208 *
5209 * diskID:
5210 * The disk to mount.
5211 *
5212 * mountDir:
5213 * Pass in NULL (currently only NULL is supported).
5214 *
5215 * mountedVolumeRefNum:
5216 * The volume ref num of the newly mounted volume.
5217 *
5218 * flags:
5219 * Options for future use.
5220 *
5221 * Availability:
5222 * Mac OS X: in version 10.2 and later in CoreServices.framework
5223 * CarbonLib: not available in CarbonLib 1.x
5224 * Non-Carbon CFM: not available
5225 }
FSMountLocalVolumeSyncnull5226 function FSMountLocalVolumeSync( diskID: CFStringRef; mountDir: CFURLRef; var mountedVolumeRefNum: FSVolumeRefNum; flags: OptionBits ): OSStatus; external name '_FSMountLocalVolumeSync';
5227 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5228
5229
5230 {
5231 * FSMountLocalVolumeAsync()
5232 *
5233 * Discussion:
5234 * This routine will start the process to disk specified by diskID
5235 * at mountDir (or the default location if mountDir is NULL). If a
5236 * callback is provided the provided function will be called when
5237 * the mount operation is complete. Once this routine returns noErr
5238 * the status of the operation can be found using
5239 * FSGetAsyncMountStatus.
5240 *
5241 * Mac OS X threading:
5242 * Thread safe since version 10.2
5243 *
5244 * Parameters:
5245 *
5246 * diskID:
5247 * The disk to mount.
5248 *
5249 * mountDir:
5250 * Pass in NULL (currently only NULL is supported).
5251 *
5252 * volumeOp:
5253 * An FSVolumeOperation returned by FSCreateVolumeOperation
5254 *
5255 * clientData:
5256 * client data associated with the operation.
5257 *
5258 * flags:
5259 * Options for future use.
5260 *
5261 * callback:
5262 * Function to call when mount is complete.
5263 *
5264 * runloop:
5265 * Runloop to run on.
5266 *
5267 * runloopMode:
5268 * Mode for runloop.
5269 *
5270 * Availability:
5271 * Mac OS X: in version 10.2 and later in CoreServices.framework
5272 * CarbonLib: not available in CarbonLib 1.x
5273 * Non-Carbon CFM: not available
5274 }
FSMountLocalVolumeAsyncnull5275 function FSMountLocalVolumeAsync( diskID: CFStringRef; mountDir: CFURLRef; volumeOp: FSVolumeOperation; clientData: UnivPtr; flags: OptionBits; callback: FSVolumeMountUPP; runloop: CFRunLoopRef; runloopMode: CFStringRef ): OSStatus; external name '_FSMountLocalVolumeAsync';
5276 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5277
5278
5279 {
5280 * FSMountServerVolumeSync()
5281 *
5282 * Discussion:
5283 * This routine will mount the server specified by url at mountDir
5284 * (or the default location if mountDir is NULL). An optional user
5285 * and password can be passed in for authentication. If no user or
5286 * password is provided then the underlying file system will handle
5287 * authentication if required. This routine returns after the mount
5288 * is complete.
5289 *
5290 * Mac OS X threading:
5291 * Thread safe since version 10.2
5292 *
5293 * Parameters:
5294 *
5295 * url:
5296 * The server to mount.
5297 *
5298 * mountDir:
5299 * The directory to mount the server to (default if NULL).
5300 *
5301 * user:
5302 * String to pass as user for authentication.
5303 *
5304 * password:
5305 * String to pass as password for authenticated log in.
5306 *
5307 * mountedVolumeRefNum:
5308 * The volume ref num of the newly mounted volume.
5309 *
5310 * flags:
5311 * Options (such as kFSMountServerMarkDoNotDisplay and
5312 * kFSMountServerMountOnMountDir).
5313 *
5314 * Availability:
5315 * Mac OS X: in version 10.2 and later in CoreServices.framework
5316 * CarbonLib: not available in CarbonLib 1.x
5317 * Non-Carbon CFM: not available
5318 }
FSMountServerVolumeSyncnull5319 function FSMountServerVolumeSync( url: CFURLRef; mountDir: CFURLRef; user: CFStringRef; password: CFStringRef; var mountedVolumeRefNum: FSVolumeRefNum; flags: OptionBits ): OSStatus; external name '_FSMountServerVolumeSync';
5320 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5321
5322
5323 {
5324 * FSMountServerVolumeAsync()
5325 *
5326 * Discussion:
5327 * This routine will start the process to mount the server specified
5328 * by url at mountDir (or the default location if mountDir is NULL).
5329 * An optional user and password can be passed in for
5330 * authentication. If no user or password is provided then the
5331 * underlying file system will handle authentication if required.
5332 * If a callback is provided the provided function will be called
5333 * when the mount operation is complete. Once this routine returns
5334 * noErr the status of the operation can be found using
5335 * FSGetAsyncMountStatus.
5336 *
5337 * Mac OS X threading:
5338 * Thread safe since version 10.2
5339 *
5340 * Parameters:
5341 *
5342 * url:
5343 * The server to mount.
5344 *
5345 * mountDir:
5346 * The directory to mount the server to (default if NULL).
5347 *
5348 * user:
5349 * String to pass as user for authentication.
5350 *
5351 * password:
5352 * String to pass as password for authenticated log in.
5353 *
5354 * volumeOp:
5355 * An FSVolumeOperation returned by FSCreateVolumeOperation
5356 *
5357 * clientData:
5358 * client data associated with the operation.
5359 *
5360 * flags:
5361 * Options (such as kFSMountServerMarkDoNotDisplay and
5362 * kFSMountServerMountOnMountDir).
5363 *
5364 * callback:
5365 * Function to call when mount is complete.
5366 *
5367 * runloop:
5368 * Runloop run on.
5369 *
5370 * runloopMode:
5371 * Mode for runloop.
5372 *
5373 * Availability:
5374 * Mac OS X: in version 10.2 and later in CoreServices.framework
5375 * CarbonLib: not available in CarbonLib 1.x
5376 * Non-Carbon CFM: not available
5377 }
FSMountServerVolumeAsyncnull5378 function FSMountServerVolumeAsync( url: CFURLRef; mountDir: CFURLRef; user: CFStringRef; password: CFStringRef; volumeOp: FSVolumeOperation; clientData: UnivPtr; flags: OptionBits; callback: FSVolumeMountUPP; runloop: CFRunLoopRef; runloopMode: CFStringRef ): OSStatus; external name '_FSMountServerVolumeAsync';
5379 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5380
5381
5382 {
5383 * FSGetAsyncMountStatus()
5384 *
5385 * Discussion:
5386 * This routine returns the current status of an asynchronous mount
5387 * operation. A return value of noErr signifies that the status
5388 * parameter has been filled with valid information. If the status
5389 * is kAsyncMountComplete then the rest of data returned is valid.
5390 * If the status is anything else then the volumeOpStatus and
5391 * mountedVolumeRefNum parameters are invalid (The clientData will
5392 * be ok).
5393 *
5394 * Mac OS X threading:
5395 * Thread safe since version 10.2
5396 *
5397 * Parameters:
5398 *
5399 * volumeOp:
5400 * The async volume operation to get status about.
5401 *
5402 * status:
5403 * The status of the operation.
5404 *
5405 * volumeOpStatus:
5406 * If status is kAsyncMountComplete then this contains the
5407 * OSStatus for the operation.
5408 *
5409 * mountedVolumeRefNum:
5410 * If status is kAsyncMountComplete and volumeOpStatus is noErr
5411 * then this is the volume ref num for the newly mounted volume.
5412 *
5413 * clientData:
5414 * client data associated with the original
5415 * FSMountServerVolumeAsync operation.
5416 *
5417 * Availability:
5418 * Mac OS X: in version 10.2 and later in CoreServices.framework
5419 * CarbonLib: not available in CarbonLib 1.x
5420 * Non-Carbon CFM: not available
5421 }
FSGetAsyncMountStatusnull5422 function FSGetAsyncMountStatus( volumeOp: FSVolumeOperation; var status: FSMountStatus; var volumeOpStatus: OSStatus; var mountedVolumeRefNum: FSVolumeRefNum; clientData: UnivPtrPtr ): OSStatus; external name '_FSGetAsyncMountStatus';
5423 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5424
5425
5426 {
5427 * FSUnmountVolumeSync()
5428 *
5429 * Discussion:
5430 * This routine unmounts the volume specified by vRefNum. If the
5431 * volume cannot be unmounted the pid of the process which denied
5432 * the unmount will be returned in the dissenter parameter. This
5433 * routine returns after the unmount is complete.
5434 *
5435 * Mac OS X threading:
5436 * Thread safe since version 10.2
5437 *
5438 * Parameters:
5439 *
5440 * vRefNum:
5441 * The volume reference number of the volume to unmount.
5442 *
5443 * flags:
5444 * Options (such as kFSUnmountVolumeForceUnmount).
5445 *
5446 * dissenter:
5447 * pid of the process which denied the unmount if the unmount is
5448 * denied.
5449 *
5450 * Availability:
5451 * Mac OS X: in version 10.2 and later in CoreServices.framework
5452 * CarbonLib: not available in CarbonLib 1.x
5453 * Non-Carbon CFM: not available
5454 }
FSUnmountVolumeSyncnull5455 function FSUnmountVolumeSync( vRefNum: FSVolumeRefNum; flags: OptionBits; var dissenter: pid_t ): OSStatus; external name '_FSUnmountVolumeSync';
5456 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5457
5458
5459 {
5460 * FSUnmountVolumeAsync()
5461 *
5462 * Discussion:
5463 * This routine starts the process of unmounting the volume
5464 * specified by vRefNum. If a callback is provided the provided
5465 * function will be called when the unmount operation is complete.
5466 * Once this routine returns noErr the status of the operation can
5467 * be found using FSGetAsyncUnmountStatus.
5468 *
5469 * Mac OS X threading:
5470 * Thread safe since version 10.2
5471 *
5472 * Parameters:
5473 *
5474 * vRefNum:
5475 * The volume reference number of the volume to unmount.
5476 *
5477 * flags:
5478 * Options (such as kFSUnmountVolumeForceUnmount).
5479 *
5480 * volumeOp:
5481 * An FSVolumeOperation returned by FSCreateVolumeOperation
5482 *
5483 * clientData:
5484 * client data associated with the operation.
5485 *
5486 * callback:
5487 * Function to call when unmount is complete.
5488 *
5489 * runloop:
5490 * Runloop to run on.
5491 *
5492 * runloopMode:
5493 * Mode for runloop.
5494 *
5495 * Availability:
5496 * Mac OS X: in version 10.2 and later in CoreServices.framework
5497 * CarbonLib: not available in CarbonLib 1.x
5498 * Non-Carbon CFM: not available
5499 }
FSUnmountVolumeAsyncnull5500 function FSUnmountVolumeAsync( vRefNum: FSVolumeRefNum; flags: OptionBits; volumeOp: FSVolumeOperation; clientData: UnivPtr; callback: FSVolumeUnmountUPP; runloop: CFRunLoopRef; runloopMode: CFStringRef ): OSStatus; external name '_FSUnmountVolumeAsync';
5501 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5502
5503
5504 {
5505 * FSGetAsyncUnmountStatus()
5506 *
5507 * Discussion:
5508 * This routine returns the current status of an asynchronous
5509 * unmount operation. A return value of noErr signifies that the
5510 * status parameter has been filled with valid information.
5511 *
5512 * Mac OS X threading:
5513 * Thread safe since version 10.2
5514 *
5515 * Parameters:
5516 *
5517 * volumeOp:
5518 * The async volume operation to get status about.
5519 *
5520 * status:
5521 * The status of the operation.
5522 *
5523 * volumeOpStatus:
5524 * If status is kAsyncUnmountComplete then this contains the
5525 * OSStatus for the operation.
5526 *
5527 * volumeRefNum:
5528 * volume reference number of volume being unmounted.
5529 *
5530 * dissenter:
5531 * pid of the process which denied the unmount if the unmount is
5532 * denied.
5533 *
5534 * clientData:
5535 * client data associated with the original
5536 * FSMountServerVolumeAsync operation.
5537 *
5538 * Availability:
5539 * Mac OS X: in version 10.2 and later in CoreServices.framework
5540 * CarbonLib: not available in CarbonLib 1.x
5541 * Non-Carbon CFM: not available
5542 }
FSGetAsyncUnmountStatusnull5543 function FSGetAsyncUnmountStatus( volumeOp: FSVolumeOperation; var status: FSUnmountStatus; var volumeOpStatus: OSStatus; var volumeRefNum: FSVolumeRefNum; var dissenter: pid_t; clientData: UnivPtrPtr ): OSStatus; external name '_FSGetAsyncUnmountStatus';
5544 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5545
5546
5547 {
5548 * FSCancelVolumeOperation()
5549 *
5550 * Discussion:
5551 * This routine will cancel and outstanding asynchronous volume
5552 * mounting operation. It currently is only supported for server
5553 * mounts.
5554 *
5555 * Mac OS X threading:
5556 * Thread safe since version 10.2
5557 *
5558 * Parameters:
5559 *
5560 * volumeOp:
5561 * The async volume operation to cancel.
5562 *
5563 * Availability:
5564 * Mac OS X: in version 10.2 and later in CoreServices.framework
5565 * CarbonLib: not available in CarbonLib 1.x
5566 * Non-Carbon CFM: not available
5567 }
FSCancelVolumeOperationnull5568 function FSCancelVolumeOperation( volumeOp: FSVolumeOperation ): OSStatus; external name '_FSCancelVolumeOperation';
5569 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5570
5571
5572 {
5573 * FSEjectVolumeSync()
5574 *
5575 * Discussion:
5576 * This routine ejects the volume specified by vRefNum. If the
5577 * volume cannot be ejected the pid of the process which denied the
5578 * unmount will be returned in the dissenter parameter. This
5579 * routine returns after the eject is complete. Ejecting a volume
5580 * will result in the unmounting of other volumes on the same device.
5581 *
5582 * Mac OS X threading:
5583 * Thread safe since version 10.2
5584 *
5585 * Parameters:
5586 *
5587 * vRefNum:
5588 * The volume reference number of the volume to eject.
5589 *
5590 * flags:
5591 * Options (such as kFSEjectVolumeForceEject).
5592 *
5593 * dissenter:
5594 * pid of the process which denied the unmount if the eject is
5595 * denied.
5596 *
5597 * Availability:
5598 * Mac OS X: in version 10.2 and later in CoreServices.framework
5599 * CarbonLib: not available in CarbonLib 1.x
5600 * Non-Carbon CFM: not available
5601 }
FSEjectVolumeSyncnull5602 function FSEjectVolumeSync( vRefNum: FSVolumeRefNum; flags: OptionBits; var dissenter: pid_t ): OSStatus; external name '_FSEjectVolumeSync';
5603 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5604
5605
5606 {
5607 * FSEjectVolumeAsync()
5608 *
5609 * Discussion:
5610 * This routine starts the process of ejecting the volume specified
5611 * by vRefNum. If a callback is provided the provided function will
5612 * be called when the eject operation is complete. Once this
5613 * routine returns noErr the status of the operation can be found
5614 * using FSGetAsyncEjectStatus.
5615 *
5616 * Mac OS X threading:
5617 * Thread safe since version 10.2
5618 *
5619 * Parameters:
5620 *
5621 * vRefNum:
5622 * The volume reference number of the volume to eject.
5623 *
5624 * flags:
5625 * Options (such as kFSEjectVolumeForceEject).
5626 *
5627 * volumeOp:
5628 * An FSVolumeOperation returned by FSCreateVolumeOperation
5629 *
5630 * clientData:
5631 * client data associated with the operation.
5632 *
5633 * callback:
5634 * Function to call when eject is complete.
5635 *
5636 * runloop:
5637 * Runloop to run on.
5638 *
5639 * runloopMode:
5640 * Mode for runloop.
5641 *
5642 * Availability:
5643 * Mac OS X: in version 10.2 and later in CoreServices.framework
5644 * CarbonLib: not available in CarbonLib 1.x
5645 * Non-Carbon CFM: not available
5646 }
FSEjectVolumeAsyncnull5647 function FSEjectVolumeAsync( vRefNum: FSVolumeRefNum; flags: OptionBits; volumeOp: FSVolumeOperation; clientData: UnivPtr; callback: FSVolumeEjectUPP; runloop: CFRunLoopRef; runloopMode: CFStringRef ): OSStatus; external name '_FSEjectVolumeAsync';
5648 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5649
5650
5651 {
5652 * FSGetAsyncEjectStatus()
5653 *
5654 * Discussion:
5655 * This routine returns the current status of an asynchronous eject
5656 * operation. A return value of noErr signifies that the status
5657 * parameter has been filled with valid information.
5658 *
5659 * Mac OS X threading:
5660 * Thread safe since version 10.2
5661 *
5662 * Parameters:
5663 *
5664 * volumeOp:
5665 * The async volume operation to get status about.
5666 *
5667 * status:
5668 * The status of the operation.
5669 *
5670 * volumeOpStatus:
5671 * If status is kAsyncEjectComplete then this contains the
5672 * OSStatus for the operation.
5673 *
5674 * volumeRefNum:
5675 * volume reference number of volume being ejected.
5676 *
5677 * dissenter:
5678 * pid of the process which denied the unmount if the eject is
5679 * denied.
5680 *
5681 * clientData:
5682 * client data associated with the original
5683 * FSMountServerVolumeAsync operation.
5684 *
5685 * Availability:
5686 * Mac OS X: in version 10.2 and later in CoreServices.framework
5687 * CarbonLib: not available in CarbonLib 1.x
5688 * Non-Carbon CFM: not available
5689 }
FSGetAsyncEjectStatusnull5690 function FSGetAsyncEjectStatus( volumeOp: FSVolumeOperation; var status: FSEjectStatus; var volumeOpStatus: OSStatus; var volumeRefNum: FSVolumeRefNum; var dissenter: pid_t; clientData: UnivPtrPtr ): OSStatus; external name '_FSGetAsyncEjectStatus';
5691 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5692
5693
5694 {
5695 * FSCopyDiskIDForVolume()
5696 *
5697 * Discussion:
5698 * This routine returns a copy of the diskID for the passed in
5699 * volume. The caller is responsible for releasing the CFString
5700 * later.
5701 *
5702 * Mac OS X threading:
5703 * Thread safe since version 10.2
5704 *
5705 * Parameters:
5706 *
5707 * vRefNum:
5708 * FSVolumeRefNum of the target volume.
5709 *
5710 * diskID:
5711 * The diskID string associated with the target volume.
5712 *
5713 * Availability:
5714 * Mac OS X: in version 10.2 and later in CoreServices.framework
5715 * CarbonLib: not available in CarbonLib 1.x
5716 * Non-Carbon CFM: not available
5717 }
FSCopyDiskIDForVolumenull5718 function FSCopyDiskIDForVolume( vRefNum: FSVolumeRefNum; var diskID: CFStringRef ): OSStatus; external name '_FSCopyDiskIDForVolume';
5719 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_2, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5720
5721
5722 {
5723 * FSCopyURLForVolume()
5724 *
5725 * Discussion:
5726 * This routine returns a copy of the url for the passed in volume.
5727 * The caller is responsible for releasing the CFURL later.
5728 *
5729 * Mac OS X threading:
5730 * Thread safe since version 10.3
5731 *
5732 * Parameters:
5733 *
5734 * vRefNum:
5735 * FSVolumeRefNum of the target volume.
5736 *
5737 * url:
5738 * The url associated with the target volume.
5739 *
5740 * Availability:
5741 * Mac OS X: in version 10.3 and later in CoreServices.framework
5742 * CarbonLib: not available in CarbonLib 1.x
5743 * Non-Carbon CFM: not available
5744 }
FSCopyURLForVolumenull5745 function FSCopyURLForVolume( vRefNum: FSVolumeRefNum; var url: CFURLRef ): OSStatus; external name '_FSCopyURLForVolume';
5746 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_3, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5747
5748
5749 {
5750 * FSGetVolumeForDiskID()
5751 *
5752 * Discussion:
5753 * This routine returnes the FSVolumeRefNum for a given diskID.
5754 *
5755 * Mac OS X threading:
5756 * Thread safe since version 10.4
5757 *
5758 * Parameters:
5759 *
5760 * diskID:
5761 * The diskID string associated with the target volume.
5762 *
5763 * vRefNum:
5764 * FSVolumeRefNum of the volume which corresponds to the diskID.
5765 *
5766 * Availability:
5767 * Mac OS X: in version 10.4 and later in CoreServices.framework
5768 * CarbonLib: not available in CarbonLib 1.x
5769 * Non-Carbon CFM: not available
5770 }
FSGetVolumeForDiskIDnull5771 function FSGetVolumeForDiskID( diskID: CFStringRef; var vRefNum: FSVolumeRefNum ): OSStatus; external name '_FSGetVolumeForDiskID';
5772 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5773
5774
5775 {
5776 * FSCopyDADiskForVolume()
5777 *
5778 * Discussion:
5779 * This routine returns a copy of the diskID for the passed in
5780 * volume. The caller is responsible for releasing the DADisk
5781 * later.
5782 *
5783 * Mac OS X threading:
5784 * Thread safe since version 10.4
5785 *
5786 * Parameters:
5787 *
5788 * vRefNum:
5789 * FSVolumeRefNum of the target volume.
5790 *
5791 * disk:
5792 * The DADisk associated with the target volume.
5793 *
5794 * Availability:
5795 * Mac OS X: in version 10.4 and later in CoreServices.framework
5796 * CarbonLib: not available in CarbonLib 1.x
5797 * Non-Carbon CFM: not available
5798 }
FSCopyDADiskForVolumenull5799 function FSCopyDADiskForVolume( vRefNum: FSVolumeRefNum; var disk: DADiskRef ): OSStatus; external name '_FSCopyDADiskForVolume';
5800 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5801
5802
5803 {
5804 * FSGetVolumeForDADisk()
5805 *
5806 * Discussion:
5807 * This routine returns the FSVolumeRefNum associated with the
5808 * volume referenced by the passed in DADiskRef.
5809 *
5810 * Mac OS X threading:
5811 * Thread safe since version 10.4
5812 *
5813 * Parameters:
5814 *
5815 * disk:
5816 * The DADiskRef of the target volume.
5817 *
5818 * vRefNum:
5819 * FSVolumeRefNum of the volume which corresponds to the DADiskRef.
5820 *
5821 * Availability:
5822 * Mac OS X: in version 10.4 and later in CoreServices.framework
5823 * CarbonLib: not available in CarbonLib 1.x
5824 * Non-Carbon CFM: not available
5825 }
FSGetVolumeForDADisknull5826 function FSGetVolumeForDADisk( disk: DADiskRef; var vRefNum: FSVolumeRefNum ): OSStatus; external name '_FSGetVolumeForDADisk';
5827 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
5828
5829
5830 { File Operation routines}
5831
5832 type
5833 FSFileOperationRef = ^__FSFileOperation; { an opaque type }
5834 __FSFileOperation = record end;
5835 FSFileOperationStage = UInt32;
5836
5837 {
5838 * FSFileOperationClientContext
5839 *
5840 * Discussion:
5841 * Structure containing the user-defined data and callbacks for
5842 * FSFileOperation client contextual data.
5843 }
5844 type
5845 FSFileOperationClientContext = record
5846 {
5847 * The version number of the structure type being passed in as a
5848 * parameter to FSCopyObjectAsync or FSMoveObjectAsync function.
5849 * Valid version number is currently 0.
5850 }
5851 version: CFIndex;
5852
5853 {
5854 * An arbitrary pointer to client-defined data, which can be
5855 * associated with the operation and is passed to the callbacks.
5856 }
5857 info: UnivPtr;
5858
5859 {
5860 * The callback used to add a retain for the operation on the info
5861 * pointer for the life of the operation, and may be used for
5862 * temporary references the operation needs to take. This callback
5863 * returns the actual info pointer to store in the operation, almost
5864 * always just the pointer passed as the parameter.
5865 }
5866 retain: CFAllocatorRetainCallBack;
5867
5868 {
5869 * The callback used to remove a retain previously added for the
5870 * operation on the info pointer.
5871 }
5872 release: CFAllocatorReleaseCallBack;
5873
5874 {
5875 * The callback used to create a descriptive string representation of
5876 * the info pointer (or the data pointed to by the info pointer) for
5877 * debugging purposes. This is used by the CFCopyDescription()
5878 * function.
5879 }
5880 copyDescription: CFAllocatorCopyDescriptionCallBack;
5881 end;
5882
5883 {
5884 * FSFileOperationStatusProcPtr
5885 *
5886 * Discussion:
5887 * Callback function which is called to return status of an
5888 * operation. It will be called when an operation changes stages
5889 * (including failing due to an error) or as updated information is
5890 * available limited by the statusChangeInterval of the operation.
5891 *
5892 * Parameters:
5893 *
5894 * fileOp:
5895 * Operation receiving the callback.
5896 *
5897 * currentItem:
5898 * FSRef to item operation is currently processing. If the
5899 * operation is complete then currentItem refers to the target
5900 * item (the new item corresponding to the source item in the
5901 * destination directory).
5902 *
5903 * stage:
5904 * Current stage of the operation.
5905 *
5906 * error:
5907 * Either noErr or an error value which caused the operation to
5908 * fail.
5909 *
5910 * statusDictionary:
5911 * A CFDictionary with more detailed status information. The
5912 * caller should not release this item. If the item is needed
5913 * beyond the scope of the callback then it needs to be copied.
5914 *
5915 * info:
5916 * The info pointer passed in by the client.
5917 }
5918 type
5919 FSFileOperationStatusProcPtr = procedure( fileOp: FSFileOperationRef; const (*var*) currentItem: FSRef; stage: FSFileOperationStage; error: OSStatus; statusDictionary: CFDictionaryRef; info: UnivPtr );
5920
5921 {
5922 * FSPathFileOperationStatusProcPtr
5923 *
5924 * Discussion:
5925 * Callback function which is called to return status of an
5926 * operation. It will be called when an operation changes stages
5927 * (including failing due to an error) or as updated information is
5928 * available limited by the statusChangeInterval of the operation.
5929 *
5930 * Parameters:
5931 *
5932 * fileOp:
5933 * Operation receiving the callback.
5934 *
5935 * currentItem:
5936 * The UTF-8 path for the item operation is currently processing.
5937 * The caller should not release this item. If the item is needed
5938 * beyond the scope of the callback then it needs to be copied.
5939 * If the operation is complete then currentItem refers to the
5940 * target item (the new item corresponding to the source item in
5941 * the destination directory).
5942 *
5943 * stage:
5944 * Current stage of the operation.
5945 *
5946 * error:
5947 * Either noErr or an error value which caused the operation to
5948 * fail.
5949 *
5950 * statusDictionary:
5951 * A CFDictionary with more detailed status information. The
5952 * caller should not release this item. If the item is needed
5953 * beyond the scope of the callback then it needs to be copied.
5954 *
5955 * info:
5956 * The info pointer passed in by the client.
5957 }
5958 type
5959 FSPathFileOperationStatusProcPtr = procedure( fileOp: FSFileOperationRef; currentItem: ConstCStringPtr; stage: FSFileOperationStage; error: OSStatus; statusDictionary: CFDictionaryRef; info: UnivPtr );
5960
5961 {
5962 * FSFileOperationOptions
5963 *
5964 * Discussion:
5965 * Set of flags that can be passed into an FSMoveObject(A)sync or
5966 * FSCopyObject(A)sync call.
5967 }
5968 const
5969 {
5970 * Use the default options - no overwrite, fail if any source item
5971 * cannot be read, cross volume moves OK.
5972 }
5973 kFSFileOperationDefaultOptions = 0;
5974
5975 {
5976 * Replace an item in the destDir that has the same name as an item
5977 * being moved/copied there.
5978 }
5979 kFSFileOperationOverwrite = $01;
5980
5981 {
5982 * Skip items that cannot be read and continue copying/moving instead
5983 * of failing the operation.
5984 }
5985 kFSFileOperationSkipSourcePermissionErrors = $02;
5986
5987 {
5988 * Do not perform a copy/delete to move an item across volume
5989 * boundries - fail the operation instead.
5990 }
5991 kFSFileOperationDoNotMoveAcrossVolumes = $04;
5992
5993 {
5994 * Skip the preflight for a directory move/copy. This will limit the
5995 * status information that can be returned since the totals will not
5996 * be calculated.
5997 }
5998 kFSFileOperationSkipPreflight = $08;
5999
6000
6001 {
6002 * FSFileOperationStage
6003 *
6004 * Discussion:
6005 * The stage corresponds to the state of an asynchronous File
6006 * Operation. The stage is reported in the operation's status
6007 * callback or as part of an FSFileOperationCopyStatus call.
6008 }
6009 const
6010 {
6011 * Operation has not started yet.
6012 }
6013 kFSOperationStageUndefined = 0;
6014
6015 {
6016 * Operation is calulating sizes and number of items involved in the
6017 * operation.
6018 }
6019 kFSOperationStagePreflighting = 1;
6020
6021 {
6022 * Operation is in progress.
6023 }
6024 kFSOperationStageRunning = 2;
6025
6026 {
6027 * Operation is done.
6028 }
6029 kFSOperationStageComplete = 3;
6030
6031 { FSFileOperation status dictionary keys}
6032 {
6033 * kFSOperationTotalBytesKey
6034 *
6035 * Discussion:
6036 * This value associated with this key in a status dictionary
6037 * returns the total number of bytes that will be moved/copied by
6038 * this operation as a CFNumber. This value is not available for a
6039 * directory operation if kFSFileOperationSkipPreflight was
6040 * specified.
6041 *
6042 * Availability:
6043 * Mac OS X: in version 10.4 and later in CoreServices.framework
6044 * CarbonLib: not available in CarbonLib 1.x
6045 * Non-Carbon CFM: not available
6046 }
6047 var kFSOperationTotalBytesKey: CFStringRef; external name '_kFSOperationTotalBytesKey'; (* attribute const *)
6048 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6049 {
6050 * kFSOperationBytesCompleteKey
6051 *
6052 * Discussion:
6053 * This value associated with this key in a status dictionary
6054 * returns the number of bytes that have been moved/copied by this
6055 * operation at the time the status call was made as a CFNumber.
6056 * During the preflight stage this value represents the currently
6057 * known number of bytes that will be copied/moved.
6058 *
6059 * Availability:
6060 * Mac OS X: in version 10.4 and later in CoreServices.framework
6061 * CarbonLib: not available in CarbonLib 1.x
6062 * Non-Carbon CFM: not available
6063 }
6064 var kFSOperationBytesCompleteKey: CFStringRef; external name '_kFSOperationBytesCompleteKey'; (* attribute const *)
6065 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6066 {
6067 * kFSOperationBytesRemainingKey
6068 *
6069 * Discussion:
6070 * This value associated with this key in a status dictionary
6071 * returns the number of bytes that remain to be moved/copied by
6072 * this operation at the time the status call was made as a
6073 * CFNumber. This value is not available for a directory operation
6074 * if kFSFileOperationSkipPreflight was specified.
6075 *
6076 * Availability:
6077 * Mac OS X: in version 10.4 and later in CoreServices.framework
6078 * CarbonLib: not available in CarbonLib 1.x
6079 * Non-Carbon CFM: not available
6080 }
6081 var kFSOperationBytesRemainingKey: CFStringRef; external name '_kFSOperationBytesRemainingKey'; (* attribute const *)
6082 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6083 {
6084 * kFSOperationTotalObjectsKey
6085 *
6086 * Discussion:
6087 * This value associated with this key in a status dictionary
6088 * returns the total number of objects that will be moved/copied by
6089 * this operation as a CFNumber. This value is not available for a
6090 * directory operation if kFSFileOperationSkipPreflight was
6091 * specified.
6092 *
6093 * Availability:
6094 * Mac OS X: in version 10.4 and later in CoreServices.framework
6095 * CarbonLib: not available in CarbonLib 1.x
6096 * Non-Carbon CFM: not available
6097 }
6098 var kFSOperationTotalObjectsKey: CFStringRef; external name '_kFSOperationTotalObjectsKey'; (* attribute const *)
6099 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6100 {
6101 * kFSOperationObjectsCompleteKey
6102 *
6103 * Discussion:
6104 * This value associated with this key in a status dictionary
6105 * returns the number of objects that have been moved/copied by this
6106 * operation at the time the status call was made as a CFNumber.
6107 * During the preflight stage this value represents the currently
6108 * known number of objects that will be copied/moved.
6109 *
6110 * Availability:
6111 * Mac OS X: in version 10.4 and later in CoreServices.framework
6112 * CarbonLib: not available in CarbonLib 1.x
6113 * Non-Carbon CFM: not available
6114 }
6115 var kFSOperationObjectsCompleteKey: CFStringRef; external name '_kFSOperationObjectsCompleteKey'; (* attribute const *)
6116 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6117 {
6118 * kFSOperationObjectsRemainingKey
6119 *
6120 * Discussion:
6121 * This value associated with this key in a status dictionary
6122 * returns the number of objects that remain to be moved/copied by
6123 * this operation at the time the status call was made as a
6124 * CFNumber. This value is not available for a directory operation
6125 * if kFSFileOperationSkipPreflight was specified.
6126 *
6127 * Availability:
6128 * Mac OS X: in version 10.4 and later in CoreServices.framework
6129 * CarbonLib: not available in CarbonLib 1.x
6130 * Non-Carbon CFM: not available
6131 }
6132 var kFSOperationObjectsRemainingKey: CFStringRef; external name '_kFSOperationObjectsRemainingKey'; (* attribute const *)
6133 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6134 {
6135 * kFSOperationTotalUserVisibleObjectsKey
6136 *
6137 * Discussion:
6138 * This value associated with this key in a status dictionary
6139 * returns the total number of user visibleobjects that will be
6140 * moved/copied by this operation as a CFNumber. This value is not
6141 * available for a directory operation if
6142 * kFSFileOperationSkipPreflight was specified. A packaged
6143 * application is one user visible object even though it is made up
6144 * of multiple files and directories.
6145 *
6146 * Availability:
6147 * Mac OS X: in version 10.4 and later in CoreServices.framework
6148 * CarbonLib: not available in CarbonLib 1.x
6149 * Non-Carbon CFM: not available
6150 }
6151 var kFSOperationTotalUserVisibleObjectsKey: CFStringRef; external name '_kFSOperationTotalUserVisibleObjectsKey'; (* attribute const *)
6152 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6153 {
6154 * kFSOperationUserVisibleObjectsCompleteKey
6155 *
6156 * Discussion:
6157 * This value associated with this key in a status dictionary
6158 * returns the number of user visible objects that have been
6159 * moved/copied by this operation at the time the status call was
6160 * made as a CFNumber. During the preflight stage this value
6161 * represents the currently known number of objects that will be
6162 * copied/moved. A packaged application is one user visible object
6163 * even though it is made up of multiple files and directories.
6164 *
6165 * Availability:
6166 * Mac OS X: in version 10.4 and later in CoreServices.framework
6167 * CarbonLib: not available in CarbonLib 1.x
6168 * Non-Carbon CFM: not available
6169 }
6170 var kFSOperationUserVisibleObjectsCompleteKey: CFStringRef; external name '_kFSOperationUserVisibleObjectsCompleteKey'; (* attribute const *)
6171 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6172 {
6173 * kFSOperationUserVisibleObjectsRemainingKey
6174 *
6175 * Discussion:
6176 * This value associated with this key in a status dictionary
6177 * returns the number of user visible objects that remain to be
6178 * moved/copied by this operation at the time the status call was
6179 * made as a CFNumber. This value is not available for a directory
6180 * operation if kFSFileOperationSkipPreflight was specified. A
6181 * packaged application is one user visible object even though it is
6182 * made up of multiple files and directories.
6183 *
6184 * Availability:
6185 * Mac OS X: in version 10.4 and later in CoreServices.framework
6186 * CarbonLib: not available in CarbonLib 1.x
6187 * Non-Carbon CFM: not available
6188 }
6189 var kFSOperationUserVisibleObjectsRemainingKey: CFStringRef; external name '_kFSOperationUserVisibleObjectsRemainingKey'; (* attribute const *)
6190 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6191 {
6192 * kFSOperationThroughputKey
6193 *
6194 * Discussion:
6195 * This value associated with this key in a status dictionary
6196 * returns the current throughput for the operation in bytes per
6197 * second as a CFNumber.
6198 *
6199 * Availability:
6200 * Mac OS X: in version 10.4 and later in CoreServices.framework
6201 * CarbonLib: not available in CarbonLib 1.x
6202 * Non-Carbon CFM: not available
6203 }
6204 var kFSOperationThroughputKey: CFStringRef; external name '_kFSOperationThroughputKey'; (* attribute const *)
6205 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6206 {
6207 * FSCopyObjectSync()
6208 *
6209 * Discussion:
6210 * This routine will copy the source object into the destination
6211 * directory. The source object can be a file or directory.
6212 *
6213 * Mac OS X threading:
6214 * Thread safe since version 10.4
6215 *
6216 * Parameters:
6217 *
6218 * source:
6219 * The source object to copy.
6220 *
6221 * destDir:
6222 * The destination directory for the copy.
6223 *
6224 * destName:
6225 * The name for the new object in the destination directory. Pass
6226 * NULL to use the source object name.
6227 *
6228 * target:
6229 * Upon successful completion a ref to the newly created object.
6230 * If source is a directory then target will be the corresponding
6231 * object in the destination directory.
6232 *
6233 * options:
6234 * One or more FSFileOperation flags
6235 *
6236 * Availability:
6237 * Mac OS X: in version 10.4 and later in CoreServices.framework
6238 * CarbonLib: not available in CarbonLib 1.x
6239 * Non-Carbon CFM: not available
6240 }
FSCopyObjectSyncnull6241 function FSCopyObjectSync( const (*var*) source: FSRef; const (*var*) destDir: FSRef; destName: CFStringRef; var target: FSRef; options: OptionBits ): OSStatus; external name '_FSCopyObjectSync';
6242 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6243
6244
6245 {
6246 * FSMoveObjectSync()
6247 *
6248 * Discussion:
6249 * This routine will move the source object into the destination
6250 * directory. The source object can be a file or directory. If a
6251 * destName is provided then the object will be renamed as well as
6252 * moved. By default a move across volumes will result in a copy
6253 * and deletion of the original source. The
6254 * kFSFileOperationDoNotMoveAcrossVolumes flag will cause cross
6255 * volume moves to do nothing and return an error.
6256 *
6257 * Mac OS X threading:
6258 * Thread safe since version 10.4
6259 *
6260 * Parameters:
6261 *
6262 * source:
6263 * The source object to move.
6264 *
6265 * destDir:
6266 * The destination directory for the move.
6267 *
6268 * destName:
6269 * The name for the object in the destination directory. Pass
6270 * NULL to use the source object name.
6271 *
6272 * target:
6273 * Upon successful completion a ref to the object in its new
6274 * location. If source is a directory then target will be the
6275 * corresponding object in the destination directory.
6276 *
6277 * options:
6278 * One or more FSFileOperation flags
6279 *
6280 * Availability:
6281 * Mac OS X: in version 10.4 and later in CoreServices.framework
6282 * CarbonLib: not available in CarbonLib 1.x
6283 * Non-Carbon CFM: not available
6284 }
FSMoveObjectSyncnull6285 function FSMoveObjectSync( const (*var*) source: FSRef; const (*var*) destDir: FSRef; destName: CFStringRef; var target: FSRef; options: OptionBits ): OSStatus; external name '_FSMoveObjectSync';
6286 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6287
6288
6289 {
6290 * FSMoveObjectToTrashSync()
6291 *
6292 * Discussion:
6293 * This routine will move the source object into the trash. The
6294 * source object can be a file or directory. If the volume the
6295 * source object resides on does not support a trash folder then
6296 * this call will return an error (this is the same circumstance
6297 * that triggers the delete immediately behavior in the Finder).
6298 *
6299 * Mac OS X threading:
6300 * Thread safe since version 10.5
6301 *
6302 * Parameters:
6303 *
6304 * source:
6305 * The source object to move to the trash.
6306 *
6307 * target:
6308 * Upon successful completion a ref the object in the trash. If
6309 * source is a directory then target will be the corresponding
6310 * object in the destination directory.
6311 *
6312 * options:
6313 * One or more FSFileOperation flags
6314 *
6315 * Availability:
6316 * Mac OS X: in version 10.5 and later in CoreServices.framework
6317 * CarbonLib: not available
6318 * Non-Carbon CFM: not available
6319 }
FSMoveObjectToTrashSyncnull6320 function FSMoveObjectToTrashSync( const (*var*) source: FSRef; var target: FSRef; options: OptionBits ): OSStatus; external name '_FSMoveObjectToTrashSync';
6321 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6322
6323
6324 {
6325 * FSPathCopyObjectSync()
6326 *
6327 * Discussion:
6328 * This routine will copy the source object into the destination
6329 * directory. The source object can be a file or directory.
6330 *
6331 * Mac OS X threading:
6332 * Thread safe since version 10.4
6333 *
6334 * Parameters:
6335 *
6336 * sourcePath:
6337 * The UTF-8 path string of the source object to copy.
6338 *
6339 * destDirPath:
6340 * The UTF-8 path of the destination directory for the copy.
6341 *
6342 * destName:
6343 * The name for the new object in the destination directory. Pass
6344 * NULL to use the source object name.
6345 *
6346 * targetPath:
6347 * A pointer to a char * to allow returning the path to the newly
6348 * created object. The path is allocated using malloc and it is
6349 * the caller's responsibility to free. The pointer will be set
6350 * to NULL if the copy failed.
6351 *
6352 * options:
6353 * One or more FSFileOperation flags
6354 *
6355 * Availability:
6356 * Mac OS X: in version 10.4 and later in CoreServices.framework
6357 * CarbonLib: not available in CarbonLib 1.x
6358 * Non-Carbon CFM: not available
6359 }
FSPathCopyObjectSyncnull6360 function FSPathCopyObjectSync( sourcePath: ConstCStringPtr; destDirPath: ConstCStringPtr; destName: CFStringRef; var targetPath: CStringPtr; options: OptionBits ): OSStatus; external name '_FSPathCopyObjectSync';
6361 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6362
6363
6364 {
6365 * FSPathMoveObjectSync()
6366 *
6367 * Discussion:
6368 * This routine will move the source object into the destination
6369 * directory. The source object can be a file or directory. If a
6370 * destName is provided then the object will be renamed as well as
6371 * moved. By default a move across volumes will result in a copy
6372 * and deletion of the original source. The
6373 * kFSFileOperationDoNotMoveAcrossVolumes flag will cause cross
6374 * volume moves to do nothing and return an error.
6375 *
6376 * Mac OS X threading:
6377 * Thread safe since version 10.4
6378 *
6379 * Parameters:
6380 *
6381 * sourcePath:
6382 * The UTF-8 path string of the source object to move.
6383 *
6384 * destDirPath:
6385 * The UTF-8 path of the destination directory for the move.
6386 *
6387 * destName:
6388 * The name for the moved object in the destination directory.
6389 * Pass NULL to use the source object name.
6390 *
6391 * targetPath:
6392 * A pointer to a char * to allow returning the path to the newly
6393 * created object. The path is allocated using malloc and it is
6394 * the caller's responsibility to free. The pointer will be set
6395 * to NULL if the move failed.
6396 *
6397 * options:
6398 * One or more FSFileOperation flags
6399 *
6400 * Availability:
6401 * Mac OS X: in version 10.4 and later in CoreServices.framework
6402 * CarbonLib: not available in CarbonLib 1.x
6403 * Non-Carbon CFM: not available
6404 }
FSPathMoveObjectSyncnull6405 function FSPathMoveObjectSync( sourcePath: ConstCStringPtr; destDirPath: ConstCStringPtr; destName: CFStringRef; var targetPath: CStringPtr; options: OptionBits ): OSStatus; external name '_FSPathMoveObjectSync';
6406 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6407
6408
6409 {
6410 * FSPathMoveObjectToTrashSync()
6411 *
6412 * Discussion:
6413 * This routine will move the source object into the trash. The
6414 * source object can be a file or directory. If the volume the
6415 * source object resides on does not support a trash folder then
6416 * this call will return an error (this is the same circumstance
6417 * that triggers the delete immediately behavior in the Finder).
6418 *
6419 * Mac OS X threading:
6420 * Thread safe since version 10.5
6421 *
6422 * Parameters:
6423 *
6424 * sourcePath:
6425 * The UTF-8 path string of the source object to move.
6426 *
6427 * targetPath:
6428 * A pointer to a char * to allow returning the path to the newly
6429 * created object. The path is allocated using malloc and it is
6430 * the caller's responsibility to free. The pointer will be set
6431 * to NULL if the move failed.
6432 *
6433 * options:
6434 * One or more FSFileOperation flags
6435 *
6436 * Availability:
6437 * Mac OS X: in version 10.5 and later in CoreServices.framework
6438 * CarbonLib: not available
6439 * Non-Carbon CFM: not available
6440 }
FSPathMoveObjectToTrashSyncnull6441 function FSPathMoveObjectToTrashSync( sourcePath: ConstCStringPtr; var targetPath: CStringPtr; options: OptionBits ): OSStatus; external name '_FSPathMoveObjectToTrashSync';
6442 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6443
6444
6445 {
6446 * FSFileOperationGetTypeID()
6447 *
6448 * Discussion:
6449 * This routine will return the CFTypeID for the FSFileOpeation type.
6450 *
6451 * Mac OS X threading:
6452 * Thread safe since version 10.4
6453 *
6454 * Result:
6455 * the CFTypeID for the FSFileOperation type.
6456 *
6457 * Availability:
6458 * Mac OS X: in version 10.4 and later in CoreServices.framework
6459 * CarbonLib: not available in CarbonLib 1.x
6460 * Non-Carbon CFM: not available
6461 }
FSFileOperationGetTypeIDnull6462 function FSFileOperationGetTypeID: CFTypeID; external name '_FSFileOperationGetTypeID';
6463 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6464
6465
6466 {
6467 * FSFileOperationCreate()
6468 *
6469 * Discussion:
6470 * This routine will create an FSFileOperation for use with either
6471 * FSCopyObjectAsync or FSMoveObjectAsync.
6472 *
6473 * Mac OS X threading:
6474 * Thread safe since version 10.4
6475 *
6476 * Parameters:
6477 *
6478 * alloc:
6479 * The CFAllocator to use. Pass NULL for the default allocator.
6480 *
6481 * Result:
6482 * A reference to the newly created object or NULL if the creation
6483 * failed.
6484 *
6485 * Availability:
6486 * Mac OS X: in version 10.4 and later in CoreServices.framework
6487 * CarbonLib: not available in CarbonLib 1.x
6488 * Non-Carbon CFM: not available
6489 }
FSFileOperationCreatenull6490 function FSFileOperationCreate( alloc: CFAllocatorRef ): FSFileOperationRef; external name '_FSFileOperationCreate';
6491 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6492
6493
6494 {
6495 * FSFileOperationScheduleWithRunLoop()
6496 *
6497 * Discussion:
6498 * Schedule the given operation on the specified runloop and mode. A
6499 * FSFileOperation can be scheduled on multiple runloop/mode
6500 * combinations. An opertion must be scheduled on at least one
6501 * runloop.
6502 *
6503 * Mac OS X threading:
6504 * Thread safe since version 10.4
6505 *
6506 * Parameters:
6507 *
6508 * fileOp:
6509 * The FSFileOperation to schedule.
6510 *
6511 * runLoop:
6512 * The runLoop on which to schedule the operation. Must be
6513 * non-NULL.
6514 *
6515 * runLoopMode:
6516 * The mode on which to schedule the operation. Must be non-NULL.
6517 *
6518 * Availability:
6519 * Mac OS X: in version 10.4 and later in CoreServices.framework
6520 * CarbonLib: not available in CarbonLib 1.x
6521 * Non-Carbon CFM: not available
6522 }
FSFileOperationScheduleWithRunLoopnull6523 function FSFileOperationScheduleWithRunLoop( fileOp: FSFileOperationRef; runLoop: CFRunLoopRef; runLoopMode: CFStringRef ): OSStatus; external name '_FSFileOperationScheduleWithRunLoop';
6524 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6525
6526
6527 {
6528 * FSFileOperationUnscheduleFromRunLoop()
6529 *
6530 * Discussion:
6531 * Unschedule the given operation from the specified runloop and
6532 * mode.
6533 *
6534 * Mac OS X threading:
6535 * Thread safe since version 10.4
6536 *
6537 * Parameters:
6538 *
6539 * fileOp:
6540 * The FSFileOperation to unschedule.
6541 *
6542 * runLoop:
6543 * The runLoop from which to unschedule the operation. Must be
6544 * non-NULL.
6545 *
6546 * runLoopMode:
6547 * The mode from which to unschedule the operation. Must be
6548 * non-NULL.
6549 *
6550 * Availability:
6551 * Mac OS X: in version 10.4 and later in CoreServices.framework
6552 * CarbonLib: not available in CarbonLib 1.x
6553 * Non-Carbon CFM: not available
6554 }
FSFileOperationUnscheduleFromRunLoopnull6555 function FSFileOperationUnscheduleFromRunLoop( fileOp: FSFileOperationRef; runLoop: CFRunLoopRef; runLoopMode: CFStringRef ): OSStatus; external name '_FSFileOperationUnscheduleFromRunLoop';
6556 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6557
6558
6559 {
6560 * FSCopyObjectAsync()
6561 *
6562 * Discussion:
6563 * This routine will start an asynchronous copy of the object
6564 * specified by source to the directory specified by destDir. If
6565 * destName is provided then the new object will be renamed to
6566 * destName. If destName is not provided then the name of the
6567 * source object will be used. Status callbacks will occur on one
6568 * of the runloop/mode combinations that the operation was scheduled
6569 * on (and is running).
6570 *
6571 * Mac OS X threading:
6572 * Thread safe since version 10.4
6573 *
6574 * Parameters:
6575 *
6576 * fileOp:
6577 * The FSFileOperation object created for this operation.
6578 *
6579 * source:
6580 * The source object to copy.
6581 *
6582 * destDir:
6583 * The destination directory for the copy.
6584 *
6585 * destName:
6586 * The name for the new object in the destination directory. Pass
6587 * NULL to use the source object name.
6588 *
6589 * flags:
6590 * One or more FSFileOperation flags
6591 *
6592 * callback:
6593 * An optional FSFileOperationStatusProcPtr which will be called
6594 * with status updates as the copy proceeds.
6595 *
6596 * statusChangeInterval:
6597 * The minimum time between callbacks within a single stage of an
6598 * operation.
6599 *
6600 * clientContext:
6601 * Client contextual information to associate with this operation.
6602 * The info pointer will be passed to status callbacks.
6603 *
6604 * Availability:
6605 * Mac OS X: in version 10.4 and later in CoreServices.framework
6606 * CarbonLib: not available in CarbonLib 1.x
6607 * Non-Carbon CFM: not available
6608 }
FSCopyObjectAsyncnull6609 function FSCopyObjectAsync( fileOp: FSFileOperationRef; const (*var*) source: FSRef; const (*var*) destDir: FSRef; destName: CFStringRef; flags: OptionBits; callback: FSFileOperationStatusProcPtr; statusChangeInterval: CFTimeInterval; var clientContext: FSFileOperationClientContext ): OSStatus; external name '_FSCopyObjectAsync';
6610 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6611
6612
6613 {
6614 * FSMoveObjectAsync()
6615 *
6616 * Discussion:
6617 * This routine will start an asynchronous move of the object
6618 * specified by source to the directory specified by destDir. If
6619 * destName is provided then the new object will be renamed to
6620 * destName. If destName is not provided then the name of the
6621 * source object will be used. Status callbacks will occur on one
6622 * of the runloop/mode combinations that the operation was scheduled
6623 * on (and is running). By default a move across volumes will
6624 * result in a copy and deletion of the original source. The
6625 * kFSFileOperationDoNotMoveAcrossVolumes flag will cause cross
6626 * volume moves to do nothing and return an error.
6627 *
6628 * Mac OS X threading:
6629 * Thread safe since version 10.4
6630 *
6631 * Parameters:
6632 *
6633 * fileOp:
6634 * The FSFileOperation object created for this operation.
6635 *
6636 * source:
6637 * The source object to move.
6638 *
6639 * destDir:
6640 * The destination directory for the move.
6641 *
6642 * destName:
6643 * The name for the object in the destination directory. Pass
6644 * NULL to leave the name unchanged.
6645 *
6646 * flags:
6647 * One or more FSFileOperation flags
6648 *
6649 * callback:
6650 * An optional FSFileOperationStatusProcPtr which will be called
6651 * with status updates as the copy proceeds.
6652 *
6653 * statusChangeInterval:
6654 * The minimum time between callbacks within a single stage of an
6655 * operation.
6656 *
6657 * clientContext:
6658 * Client contextual information to associate with this operation.
6659 * The info pointer will be passed to status callbacks.
6660 *
6661 * Availability:
6662 * Mac OS X: in version 10.4 and later in CoreServices.framework
6663 * CarbonLib: not available in CarbonLib 1.x
6664 * Non-Carbon CFM: not available
6665 }
FSMoveObjectAsyncnull6666 function FSMoveObjectAsync( fileOp: FSFileOperationRef; const (*var*) source: FSRef; const (*var*) destDir: FSRef; destName: CFStringRef; flags: OptionBits; callback: FSFileOperationStatusProcPtr; statusChangeInterval: CFTimeInterval; var clientContext: FSFileOperationClientContext ): OSStatus; external name '_FSMoveObjectAsync';
6667 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6668
6669
6670 {
6671 * FSMoveObjectToTrashAsync()
6672 *
6673 * Discussion:
6674 * This routine will start an asynchronous move of the object
6675 * specified by source to the trash. If the volume the source
6676 * object resides on does not support a trash folder then the
6677 * operation will return an error (this is the same circumstance
6678 * that triggers the delete immediately behavior in the Finder).
6679 * Status callbacks will occur on one of the runloop/mode
6680 * combinations that the operation was scheduled on (and is
6681 * running). Upon successul complettion of the operation the last
6682 * currentItem (from either the last status callback or retrieved by
6683 * FSFileOperationCopyStatus) will be object in the trash.
6684 *
6685 * Mac OS X threading:
6686 * Thread safe since version 10.5
6687 *
6688 * Parameters:
6689 *
6690 * fileOp:
6691 * The FSFileOperation object created for this operation.
6692 *
6693 * source:
6694 * The source object to move.
6695 *
6696 * flags:
6697 * One or more FSFileOperation flags
6698 *
6699 * callback:
6700 * An optional FSFileOperationStatusProcPtr which will be called
6701 * with status updates as the move proceeds.
6702 *
6703 * statusChangeInterval:
6704 * The minimum time between callbacks within a single stage of an
6705 * operation.
6706 *
6707 * clientContext:
6708 * Client contextual information to associate with this operation.
6709 * The info pointer will be passed to status callbacks.
6710 *
6711 * Availability:
6712 * Mac OS X: in version 10.5 and later in CoreServices.framework
6713 * CarbonLib: not available
6714 * Non-Carbon CFM: not available
6715 }
FSMoveObjectToTrashAsyncnull6716 function FSMoveObjectToTrashAsync( fileOp: FSFileOperationRef; const (*var*) source: FSRef; flags: OptionBits; callback: FSFileOperationStatusProcPtr; statusChangeInterval: CFTimeInterval; var clientContext: FSFileOperationClientContext ): OSStatus; external name '_FSMoveObjectToTrashAsync';
6717 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6718
6719
6720 {
6721 * FSPathCopyObjectAsync()
6722 *
6723 * Discussion:
6724 * This routine will start an asynchronous copy of the object
6725 * specified by source to the directory specified by destDir. If
6726 * destName is provided then the new object will be renamed to
6727 * destName. If destName is not provided then the name of the
6728 * source object will be used. Status callbacks will occur on one
6729 * of the runloop/mode combinations that the operation was scheduled
6730 * on (and is running).
6731 *
6732 * Mac OS X threading:
6733 * Thread safe since version 10.4
6734 *
6735 * Parameters:
6736 *
6737 * fileOp:
6738 * The FSFileOperation object created for this operation.
6739 *
6740 * sourcePath:
6741 * The UTF-8 path string of the source object to copy.
6742 *
6743 * destDirPath:
6744 * The UTF-8 path of the destination directory for the copy.
6745 *
6746 * destName:
6747 * The name for the new object in the destination directory. Pass
6748 * NULL to use the source object name.
6749 *
6750 * flags:
6751 * One or more FSFileOperation flags
6752 *
6753 * callback:
6754 * An optional FSPathFileOperationStatusProcPtr which will be
6755 * called with status updates as the copy proceeds.
6756 *
6757 * statusChangeInterval:
6758 * The minimum time between callbacks within a single stage of an
6759 * operation.
6760 *
6761 * clientContext:
6762 * Client contextual information to associate with this operation.
6763 * The info pointer will be passed to status callbacks.
6764 *
6765 * Availability:
6766 * Mac OS X: in version 10.4 and later in CoreServices.framework
6767 * CarbonLib: not available in CarbonLib 1.x
6768 * Non-Carbon CFM: not available
6769 }
FSPathCopyObjectAsyncnull6770 function FSPathCopyObjectAsync( fileOp: FSFileOperationRef; sourcePath: ConstCStringPtr; destDirPath: ConstCStringPtr; destName: CFStringRef; flags: OptionBits; callback: FSPathFileOperationStatusProcPtr; statusChangeInterval: CFTimeInterval; var clientContext: FSFileOperationClientContext ): OSStatus; external name '_FSPathCopyObjectAsync';
6771 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6772
6773
6774 {
6775 * FSPathMoveObjectAsync()
6776 *
6777 * Discussion:
6778 * This routine will start an asynchronous move of the object
6779 * specified by source to the directory specified by destDir. If
6780 * destName is provided then the new object will be renamed to
6781 * destName. If destName is not provided then the name of the
6782 * source object will be used. Status callbacks will occur on one
6783 * of the runloop/mode combinations that the operation was scheduled
6784 * on (and is running). By default a move across volumes will
6785 * result in a copy and deletion of the original source. The
6786 * kFSFileOperationDoNotMoveAcrossVolumes flag will cause cross
6787 * volume moves to do nothing and return an error.
6788 *
6789 * Mac OS X threading:
6790 * Thread safe since version 10.4
6791 *
6792 * Parameters:
6793 *
6794 * fileOp:
6795 * The FSFileOperation object created for this operation.
6796 *
6797 * sourcePath:
6798 * The UTF-8 path string of the source object to move.
6799 *
6800 * destDirPath:
6801 * The UTF-8 path of the destination directory for the move.
6802 *
6803 * destName:
6804 * The name for the object in the destination directory. Pass
6805 * NULL to leave the name unchanged.
6806 *
6807 * flags:
6808 * One or more FSFileOperation flags
6809 *
6810 * callback:
6811 * An optional FSPathFileOperationStatusProcPtr which will be
6812 * called with status updates as the move proceeds.
6813 *
6814 * statusChangeInterval:
6815 * The minimum time between callbacks within a single stage of an
6816 * operation.
6817 *
6818 * clientContext:
6819 * Client contextual information to associate with this operation.
6820 * The info pointer will be passed to status callbacks.
6821 *
6822 * Availability:
6823 * Mac OS X: in version 10.4 and later in CoreServices.framework
6824 * CarbonLib: not available in CarbonLib 1.x
6825 * Non-Carbon CFM: not available
6826 }
FSPathMoveObjectAsyncnull6827 function FSPathMoveObjectAsync( fileOp: FSFileOperationRef; sourcePath: ConstCStringPtr; destDirPath: ConstCStringPtr; destName: CFStringRef; flags: OptionBits; callback: FSPathFileOperationStatusProcPtr; statusChangeInterval: CFTimeInterval; var clientContext: FSFileOperationClientContext ): OSStatus; external name '_FSPathMoveObjectAsync';
6828 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6829
6830
6831 {
6832 * FSPathMoveObjectToTrashAsync()
6833 *
6834 * Discussion:
6835 * This routine will start an asynchronous move of the object
6836 * specified by source to the trash. If the volume the source
6837 * object resides on does not support a trash folder then this call
6838 * will return an error (this is the same circumstance that triggers
6839 * the delete immediately behavior in the Finder). Status callbacks
6840 * will occur on one of the runloop/mode combinations that the
6841 * operation was scheduled on (and is running). Note that the
6842 * object may be renamed when placed in the trash. Upon successful
6843 * completion of the operation the last currentItem (from either the
6844 * last status callback or retrieved by
6845 * FSPathFileOperationCopyStatus) will be object in the trash.
6846 *
6847 * Mac OS X threading:
6848 * Thread safe since version 10.5
6849 *
6850 * Parameters:
6851 *
6852 * fileOp:
6853 * The FSFileOperation object created for this operation.
6854 *
6855 * sourcePath:
6856 * The UTF-8 path string of the source object to move.
6857 *
6858 * flags:
6859 * One or more FSFileOperation flags
6860 *
6861 * callback:
6862 * An optional FSPathFileOperationStatusProcPtr which will be
6863 * called with status updates as the move proceeds.
6864 *
6865 * statusChangeInterval:
6866 * The minimum time between callbacks within a single stage of an
6867 * operation.
6868 *
6869 * clientContext:
6870 * Client contextual information to associate with this operation.
6871 * The info pointer will be passed to status callbacks.
6872 *
6873 * Availability:
6874 * Mac OS X: in version 10.5 and later in CoreServices.framework
6875 * CarbonLib: not available
6876 * Non-Carbon CFM: not available
6877 }
FSPathMoveObjectToTrashAsyncnull6878 function FSPathMoveObjectToTrashAsync( fileOp: FSFileOperationRef; sourcePath: ConstCStringPtr; flags: OptionBits; callback: FSPathFileOperationStatusProcPtr; statusChangeInterval: CFTimeInterval; var clientContext: FSFileOperationClientContext ): OSStatus; external name '_FSPathMoveObjectToTrashAsync';
6879 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6880
6881
6882 {
6883 * FSFileOperationCancel()
6884 *
6885 * Discussion:
6886 * Cancels the specified FSFileOperation. This makes the operation
6887 * ineligible to run on any runloop.
6888 *
6889 * Mac OS X threading:
6890 * Thread safe since version 10.4
6891 *
6892 * Parameters:
6893 *
6894 * fileOp:
6895 * The FSFileOperation to cancel.
6896 *
6897 * Availability:
6898 * Mac OS X: in version 10.4 and later in CoreServices.framework
6899 * CarbonLib: not available in CarbonLib 1.x
6900 * Non-Carbon CFM: not available
6901 }
FSFileOperationCancelnull6902 function FSFileOperationCancel( fileOp: FSFileOperationRef ): OSStatus; external name '_FSFileOperationCancel';
6903 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6904
6905
6906 {
6907 * FSFileOperationCopyStatus()
6908 *
6909 * Discussion:
6910 * This routine returns the current status of an FSFileOperation.
6911 * The status dictionary must be released by the caller.
6912 *
6913 * Mac OS X threading:
6914 * Thread safe since version 10.4
6915 *
6916 * Parameters:
6917 *
6918 * fileOp:
6919 * The FSFileOperation from which to retrieve status information.
6920 *
6921 * currentItem:
6922 * FSRef to item operation is currently processing. If the
6923 * operation is complete then currentItem refers to the target
6924 * item (the new item corresponding to the source item in the
6925 * destination directory).
6926 *
6927 * stage:
6928 * current stage of the operation.
6929 *
6930 * error:
6931 * Either noErr or an error value which caused the operation to
6932 * fail.
6933 *
6934 * statusDictionary:
6935 * A CFDictionary with more detailed status information. The
6936 * caller is responsible for releasing the object when done with
6937 * it.
6938 *
6939 * info:
6940 * The info pointer passed in by the client.
6941 *
6942 * Availability:
6943 * Mac OS X: in version 10.4 and later in CoreServices.framework
6944 * CarbonLib: not available in CarbonLib 1.x
6945 * Non-Carbon CFM: not available
6946 }
FSFileOperationCopyStatusnull6947 function FSFileOperationCopyStatus( fileOp: FSFileOperationRef; var currentItem: FSRef; var stage: FSFileOperationStage; var error: OSStatus; var statusDictionary: CFDictionaryRef; info: UnivPtrPtr ): OSStatus; external name '_FSFileOperationCopyStatus';
6948 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6949
6950
6951 {
6952 * FSPathFileOperationCopyStatus()
6953 *
6954 * Discussion:
6955 * This routine returns the current status of an FSFileOperation.
6956 * The status dictionary must be released by the caller.
6957 *
6958 * Mac OS X threading:
6959 * Thread safe since version 10.4
6960 *
6961 * Parameters:
6962 *
6963 * fileOp:
6964 * The FSFileOperation from which to retrieve status information.
6965 *
6966 * currentItem:
6967 * A path to the item operation is currently processing. The
6968 * caller is responsible for calling free to dispose of the path
6969 * string. If the operation is complete then currentItem refers
6970 * to the target item (the new item corresponding to the source
6971 * item in the destination directory).
6972 *
6973 * stage:
6974 * current stage of the operation.
6975 *
6976 * error:
6977 * Either noErr or an error value which caused the operation to
6978 * fail.
6979 *
6980 * statusDictionary:
6981 * A CFDictionary with more detailed status information. The
6982 * caller is responsible for releasing the object when done with
6983 * it.
6984 *
6985 * info:
6986 * The info pointer passed in by the client.
6987 *
6988 * Availability:
6989 * Mac OS X: in version 10.4 and later in CoreServices.framework
6990 * CarbonLib: not available in CarbonLib 1.x
6991 * Non-Carbon CFM: not available
6992 }
FSPathFileOperationCopyStatusnull6993 function FSPathFileOperationCopyStatus( fileOp: FSFileOperationRef; var currentItem: CStringPtr; var stage: FSFileOperationStage; var error: OSStatus; var statusDictionary: CFDictionaryRef; info: UnivPtrPtr ): OSStatus; external name '_FSPathFileOperationCopyStatus';
6994 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
6995
6996
6997 { String conversion functions}
6998 {
6999 * FSCreateStringFromHFSUniStr()
7000 *
7001 * Discussion:
7002 * Creates a CFString from a HFSUniStr255.
7003 *
7004 * Mac OS X threading:
7005 * Thread safe since version 10.4
7006 *
7007 * Parameters:
7008 *
7009 * alloc:
7010 * The CFAllocator to use. Pass NULL for the default allocator.
7011 *
7012 * uniStr:
7013 * A HFSUniStr255 to use as the source value for the CFString.
7014 *
7015 * Result:
7016 * A CFStringRef created from the HFSUniStr255 or NULL.
7017 *
7018 * Availability:
7019 * Mac OS X: in version 10.4 and later in CoreServices.framework
7020 * CarbonLib: not available in CarbonLib 1.x
7021 * Non-Carbon CFM: not available
7022 }
FSCreateStringFromHFSUniStrnull7023 function FSCreateStringFromHFSUniStr( alloc: CFAllocatorRef; const (*var*) uniStr: HFSUniStr255 ): CFStringRef; external name '_FSCreateStringFromHFSUniStr';
7024 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7025
7026
7027 {
7028 * FSGetHFSUniStrFromString()
7029 *
7030 * Discussion:
7031 * Convert a CFString into a HFSUniStr255.
7032 *
7033 * Mac OS X threading:
7034 * Thread safe since version 10.4
7035 *
7036 * Parameters:
7037 *
7038 * theString:
7039 * The CFString to convert to a HFSUniStr255.
7040 *
7041 * uniStr:
7042 * A pointer to a HFSUniStr255 which will be filled in using the
7043 * value of theString.
7044 *
7045 * Availability:
7046 * Mac OS X: in version 10.4 and later in CoreServices.framework
7047 * CarbonLib: not available in CarbonLib 1.x
7048 * Non-Carbon CFM: not available
7049 }
FSGetHFSUniStrFromStringnull7050 function FSGetHFSUniStrFromString( theString: CFStringRef; var uniStr: {out} HFSUniStr255 ): OSStatus; external name '_FSGetHFSUniStrFromString';
7051 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7052
7053
7054 { ACL support}
7055
7056 {
7057 * FSFileSecurityGetTypeID()
7058 *
7059 * Discussion:
7060 * This routine will return the CFTypeID for the FSFileSecurity type.
7061 *
7062 * Mac OS X threading:
7063 * Thread safe since version 10.4
7064 *
7065 * Result:
7066 * the CFTypeID for the FSFilSecurity type.
7067 *
7068 * Availability:
7069 * Mac OS X: in version 10.4 and later in CoreServices.framework
7070 * CarbonLib: not available in CarbonLib 1.x
7071 * Non-Carbon CFM: not available
7072 }
FSFileSecurityGetTypeIDnull7073 function FSFileSecurityGetTypeID: CFTypeID; external name '_FSFileSecurityGetTypeID';
7074 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7075
7076
7077 {
7078 * FSFileSecurityCreate()
7079 *
7080 * Discussion:
7081 * This routine will create an FSFileSecurity object. The object
7082 * should be released using CFRelease when it is no longer needed.
7083 *
7084 * Mac OS X threading:
7085 * Thread safe since version 10.4
7086 *
7087 * Parameters:
7088 *
7089 * alloc:
7090 * The CFAllocator to use. Pass NULL for the default allocator.
7091 *
7092 * Result:
7093 * A reference to the newly created object or NULL if the creation
7094 * failed.
7095 *
7096 * Availability:
7097 * Mac OS X: in version 10.4 and later in CoreServices.framework
7098 * CarbonLib: not available in CarbonLib 1.x
7099 * Non-Carbon CFM: not available
7100 }
FSFileSecurityCreatenull7101 function FSFileSecurityCreate( alloc: CFAllocatorRef ): FSFileSecurityRef; external name '_FSFileSecurityCreate';
7102 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7103
7104
7105 {
7106 * FSFileSecurityCreateWithFSPermissionInfo()
7107 *
7108 * Mac OS X threading:
7109 * Thread safe since version 10.4
7110 *
7111 * Availability:
7112 * Mac OS X: in version 10.4 and later in CoreServices.framework
7113 * CarbonLib: not available in CarbonLib 1.x
7114 * Non-Carbon CFM: not available
7115 }
FSFileSecurityCreateWithFSPermissionInfonull7116 function FSFileSecurityCreateWithFSPermissionInfo( alloc: CFAllocatorRef; const (*var*) permissions: FSPermissionInfo ): FSFileSecurityRef; external name '_FSFileSecurityCreateWithFSPermissionInfo';
7117 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7118
7119
7120 {
7121 * FSFileSecurityRefCreateCopy()
7122 *
7123 * Mac OS X threading:
7124 * Thread safe since version 10.4
7125 *
7126 * Availability:
7127 * Mac OS X: in version 10.4 and later in CoreServices.framework
7128 * CarbonLib: not available in CarbonLib 1.x
7129 * Non-Carbon CFM: not available
7130 }
FSFileSecurityRefCreateCopynull7131 function FSFileSecurityRefCreateCopy( alloc: CFAllocatorRef; fileSec: FSFileSecurityRef ): FSFileSecurityRef; external name '_FSFileSecurityRefCreateCopy';
7132 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7133
7134
7135 { get and set properties}
7136
7137 {
7138 * FSFileSecurityGetOwnerUUID()
7139 *
7140 * Discussion:
7141 * This routine will get the owner UUID associated with the passed
7142 * in FSFileSecurityRef. In there is no owner UUID property
7143 * associated with the FSFileSecurity object then
7144 * errFSPropertyNotValid will be returned.
7145 *
7146 * Mac OS X threading:
7147 * Thread safe since version 10.4
7148 *
7149 * Parameters:
7150 *
7151 * fileSec:
7152 * A reference to the FSFileSecurity object to get the owner UUID
7153 * from.
7154 *
7155 * owner:
7156 * A pointer to storage for the owner UUID associated with fileSec.
7157 *
7158 * Availability:
7159 * Mac OS X: in version 10.4 and later in CoreServices.framework
7160 * CarbonLib: not available in CarbonLib 1.x
7161 * Non-Carbon CFM: not available
7162 }
FSFileSecurityGetOwnerUUIDnull7163 function FSFileSecurityGetOwnerUUID( fileSec: FSFileSecurityRef; var owner: CFUUIDBytes ): OSStatus; external name '_FSFileSecurityGetOwnerUUID';
7164 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7165
7166
7167 {
7168 * FSFileSecuritySetOwnerUUID()
7169 *
7170 * Discussion:
7171 * This routine will set the owner UUID associated with the passed
7172 * in FSFileSecurityRef.
7173 *
7174 * Mac OS X threading:
7175 * Thread safe since version 10.4
7176 *
7177 * Parameters:
7178 *
7179 * fileSec:
7180 * A reference to the FSFileSecurity object to set the owner UUID
7181 * for.
7182 *
7183 * owner:
7184 * The UUID to set as the owner UUID associated with fileSec.
7185 *
7186 * Availability:
7187 * Mac OS X: in version 10.4 and later in CoreServices.framework
7188 * CarbonLib: not available in CarbonLib 1.x
7189 * Non-Carbon CFM: not available
7190 }
FSFileSecuritySetOwnerUUIDnull7191 function FSFileSecuritySetOwnerUUID( fileSec: FSFileSecurityRef; const (*var*) owner: CFUUIDBytes ): OSStatus; external name '_FSFileSecuritySetOwnerUUID';
7192 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7193
7194
7195 {
7196 * FSFileSecurityGetGroupUUID()
7197 *
7198 * Discussion:
7199 * This routine will get the group UUID associated with the passed
7200 * in FSFileSecurityRef. In there is no group UUID property
7201 * associated with the FSFileSecurity object then
7202 * errFSPropertyNotValid will be returned.
7203 *
7204 * Mac OS X threading:
7205 * Thread safe since version 10.4
7206 *
7207 * Parameters:
7208 *
7209 * fileSec:
7210 * A reference to the FSFileSecurity object to get the group UUID
7211 * from.
7212 *
7213 * group:
7214 * A pointer to storage for the owner UUID associated with fileSec.
7215 *
7216 * Availability:
7217 * Mac OS X: in version 10.4 and later in CoreServices.framework
7218 * CarbonLib: not available in CarbonLib 1.x
7219 * Non-Carbon CFM: not available
7220 }
FSFileSecurityGetGroupUUIDnull7221 function FSFileSecurityGetGroupUUID( fileSec: FSFileSecurityRef; var group: CFUUIDBytes ): OSStatus; external name '_FSFileSecurityGetGroupUUID';
7222 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7223
7224
7225 {
7226 * FSFileSecuritySetGroupUUID()
7227 *
7228 * Discussion:
7229 * This routine will set the group UUID associated with the passed
7230 * in FSFileSecurityRef.
7231 *
7232 * Mac OS X threading:
7233 * Thread safe since version 10.4
7234 *
7235 * Parameters:
7236 *
7237 * fileSec:
7238 * A reference to the FSFileSecurity object to set the group UUID
7239 * for.
7240 *
7241 * group:
7242 * The UUID to set as the group UUID associated with fileSec.
7243 *
7244 * Availability:
7245 * Mac OS X: in version 10.4 and later in CoreServices.framework
7246 * CarbonLib: not available in CarbonLib 1.x
7247 * Non-Carbon CFM: not available
7248 }
FSFileSecuritySetGroupUUIDnull7249 function FSFileSecuritySetGroupUUID( fileSec: FSFileSecurityRef; const (*var*) group: CFUUIDBytes ): OSStatus; external name '_FSFileSecuritySetGroupUUID';
7250 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7251
7252
7253 {
7254 * FSFileSecurityCopyAccessControlList()
7255 *
7256 * Discussion:
7257 * This routine will copy the acl_t associated with the passed in
7258 * FSFileSecurityRef. The accessControlList returned by this
7259 * routine is a copy and must be released using acl_free. The
7260 * accessControlList is an acl_t and is meant to be manipulated
7261 * using the acl calls defined in <sys/acl.h>. If there is no acl
7262 * property associated with the FSFileSecurity object then
7263 * errFSPropertyNotValid will be returned.
7264 *
7265 * Mac OS X threading:
7266 * Thread safe since version 10.4
7267 *
7268 * Parameters:
7269 *
7270 * fileSec:
7271 * A reference to the FSFileSecurity object to set the group for.
7272 *
7273 * accessControlList:
7274 * A pointer to storage for the acl_t associated with fileSec.
7275 *
7276 * Availability:
7277 * Mac OS X: in version 10.4 and later in CoreServices.framework
7278 * CarbonLib: not available in CarbonLib 1.x
7279 * Non-Carbon CFM: not available
7280 }
FSFileSecurityCopyAccessControlListnull7281 function FSFileSecurityCopyAccessControlList( fileSec: FSFileSecurityRef; var accessControlList: acl_t ): OSStatus; external name '_FSFileSecurityCopyAccessControlList';
7282 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7283
7284
7285 {
7286 * FSFileSecuritySetAccessControlList()
7287 *
7288 * Discussion:
7289 * This routine will set the acl associated with the passed in
7290 * FSFileSecurityRef. To request removal of an ACL from a filesystem
7291 * object pass in kFSFileSecurityRemoveACL as the accessControlList
7292 * and set the fileSec on the target object using FSSetCatalogInfo.
7293 * Setting the accessControlList to NULL will result in the property
7294 * being unset.
7295 *
7296 * Mac OS X threading:
7297 * Thread safe since version 10.4
7298 *
7299 * Parameters:
7300 *
7301 * fileSec:
7302 * A reference to the FSFileSecurity object to set the group for.
7303 *
7304 * accessControlList:
7305 * The acl_t to set as the acl associated with fileSec.
7306 *
7307 * Availability:
7308 * Mac OS X: in version 10.4 and later in CoreServices.framework
7309 * CarbonLib: not available in CarbonLib 1.x
7310 * Non-Carbon CFM: not available
7311 }
FSFileSecuritySetAccessControlListnull7312 function FSFileSecuritySetAccessControlList( fileSec: FSFileSecurityRef; accessControlList: acl_t ): OSStatus; external name '_FSFileSecuritySetAccessControlList';
7313 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7314
7315
7316 {
7317 * FSFileSecurityGetOwner()
7318 *
7319 * Discussion:
7320 * This routine will get the owner uid associated with the passed in
7321 * FSFileSecurityRef. In there is no owner property associated with
7322 * the FSFileSecurity object then errFSPropertyNotValid will be
7323 * returned. Note that this value is not the owner UUID which is
7324 * returned by FSFileSecurityGetOwnerUUID.
7325 *
7326 * Mac OS X threading:
7327 * Thread safe since version 10.4
7328 *
7329 * Parameters:
7330 *
7331 * fileSec:
7332 * A reference to the FSFileSecurity object to get the owner from.
7333 *
7334 * owner:
7335 * A pointer to storage for the owner uid associated with fileSec.
7336 *
7337 * Availability:
7338 * Mac OS X: in version 10.4 and later in CoreServices.framework
7339 * CarbonLib: not available in CarbonLib 1.x
7340 * Non-Carbon CFM: not available
7341 }
FSFileSecurityGetOwnernull7342 function FSFileSecurityGetOwner( fileSec: FSFileSecurityRef; var owner: UInt32 ): OSStatus; external name '_FSFileSecurityGetOwner';
7343 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7344
7345
7346 {
7347 * FSFileSecuritySetOwner()
7348 *
7349 * Discussion:
7350 * This routine will set the owner uid associated with the passed in
7351 * FSFileSecurityRef.
7352 *
7353 * Mac OS X threading:
7354 * Thread safe since version 10.4
7355 *
7356 * Parameters:
7357 *
7358 * fileSec:
7359 * A reference to the FSFileSecurity object to set the owner for.
7360 *
7361 * owner:
7362 * The uid to set as the owner associated with fileSec.
7363 *
7364 * Availability:
7365 * Mac OS X: in version 10.4 and later in CoreServices.framework
7366 * CarbonLib: not available in CarbonLib 1.x
7367 * Non-Carbon CFM: not available
7368 }
FSFileSecuritySetOwnernull7369 function FSFileSecuritySetOwner( fileSec: FSFileSecurityRef; owner: UInt32 ): OSStatus; external name '_FSFileSecuritySetOwner';
7370 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7371
7372
7373 {
7374 * FSFileSecurityGetGroup()
7375 *
7376 * Discussion:
7377 * This routine will get the group gid associated with the passed in
7378 * FSFileSecurityRef. In there is no group property associated with
7379 * the FSFileSecurity object then errFSPropertyNotValid will be
7380 * returned.
7381 *
7382 * Mac OS X threading:
7383 * Thread safe since version 10.4
7384 *
7385 * Parameters:
7386 *
7387 * fileSec:
7388 * A reference to the FSFileSecurity object to get the owner from.
7389 *
7390 * group:
7391 * A pointer to storage for the group gid associated with fileSec.
7392 *
7393 * Availability:
7394 * Mac OS X: in version 10.4 and later in CoreServices.framework
7395 * CarbonLib: not available in CarbonLib 1.x
7396 * Non-Carbon CFM: not available
7397 }
FSFileSecurityGetGroupnull7398 function FSFileSecurityGetGroup( fileSec: FSFileSecurityRef; var group: UInt32 ): OSStatus; external name '_FSFileSecurityGetGroup';
7399 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7400
7401
7402 {
7403 * FSFileSecuritySetGroup()
7404 *
7405 * Discussion:
7406 * This routine will set the group gid associated with the passed in
7407 * FSFileSecurityRef.
7408 *
7409 * Mac OS X threading:
7410 * Thread safe since version 10.4
7411 *
7412 * Parameters:
7413 *
7414 * fileSec:
7415 * A reference to the FSFileSecurity object to set the group for.
7416 *
7417 * group:
7418 * The gid to set as the group associated with fileSec.
7419 *
7420 * Availability:
7421 * Mac OS X: in version 10.4 and later in CoreServices.framework
7422 * CarbonLib: not available in CarbonLib 1.x
7423 * Non-Carbon CFM: not available
7424 }
FSFileSecuritySetGroupnull7425 function FSFileSecuritySetGroup( fileSec: FSFileSecurityRef; group: UInt32 ): OSStatus; external name '_FSFileSecuritySetGroup';
7426 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7427
7428
7429 {
7430 * FSFileSecurityGetMode()
7431 *
7432 * Discussion:
7433 * This routine will get the mode associated with the passed in
7434 * FSFileSecurityRef. In there is no mode property associated with
7435 * the FSFileSecurity object then errFSPropertyNotValid will be
7436 * returned.
7437 *
7438 * Mac OS X threading:
7439 * Thread safe since version 10.4
7440 *
7441 * Parameters:
7442 *
7443 * fileSec:
7444 * A reference to the FSFileSecurity object to set the group for.
7445 *
7446 * mode:
7447 * A pointer to storage for the mode associated with fileSec.
7448 *
7449 * Availability:
7450 * Mac OS X: in version 10.4 and later in CoreServices.framework
7451 * CarbonLib: not available in CarbonLib 1.x
7452 * Non-Carbon CFM: not available
7453 }
FSFileSecurityGetModenull7454 function FSFileSecurityGetMode( fileSec: FSFileSecurityRef; var mode: UInt16 ): OSStatus; external name '_FSFileSecurityGetMode';
7455 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7456
7457
7458 {
7459 * FSFileSecuritySetMode()
7460 *
7461 * Discussion:
7462 * This routine will set the mode associated with the passed in
7463 * FSFileSecurityRef.
7464 *
7465 * Mac OS X threading:
7466 * Thread safe since version 10.4
7467 *
7468 * Parameters:
7469 *
7470 * fileSec:
7471 * A reference to the FSFileSecurity object to set the group for.
7472 *
7473 * mode:
7474 * The mode to set as the mode associated with fileSec.
7475 *
7476 * Availability:
7477 * Mac OS X: in version 10.4 and later in CoreServices.framework
7478 * CarbonLib: not available in CarbonLib 1.x
7479 * Non-Carbon CFM: not available
7480 }
FSFileSecuritySetModenull7481 function FSFileSecuritySetMode( fileSec: FSFileSecurityRef; mode: UInt16 ): OSStatus; external name '_FSFileSecuritySetMode';
7482 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7483
7484
7485 const
7486 { old names for ioPosMode flags }
7487 pleaseCacheBit = 4; { old name of kFSPleaseCacheBit }
7488 pleaseCacheMask = $0010;
7489 noCacheBit = 5; { old name of kFSNoCacheBit }
7490 noCacheMask = $0020;
7491 rdVerifyBit = 6; { old name of kFSRdVerifyBit }
7492 rdVerifyMask = $0040;
7493 rdVerify = 64; { old name of rdVerifyMask }
7494 forceReadBit = 6; { old name of kFSForceReadBit }
7495 forceReadMask = $0040;
7496 newLineBit = 7; { old name of kFSNewLineBit }
7497 newLineMask = $0080;
7498 newLineCharMask = $FF00; { old name of kFSNewLineCharMask }
7499
7500
7501 { mapping codes (ioObjType) for MapName & MapID }
7502 const
7503 kOwnerID2Name = 1;
7504 kGroupID2Name = 2;
7505 kOwnerName2ID = 3;
7506 kGroupName2ID = 4; { types of oj object to be returned (ioObjType) for _GetUGEntry }
7507 kReturnNextUser = 1;
7508 kReturnNextGroup = 2;
7509 kReturnNextUG = 3;
7510
7511 { vcbFlags bits }
7512 const
7513 kVCBFlagsIdleFlushBit = 3; { Set if volume should be flushed at idle time }
7514 kVCBFlagsIdleFlushMask = $0008;
7515 kVCBFlagsHFSPlusAPIsBit = 4; { Set if volume implements HFS Plus APIs itself (not via emulation) }
7516 kVCBFlagsHFSPlusAPIsMask = $0010;
7517 kVCBFlagsHardwareGoneBit = 5; { Set if disk driver returned a hardwareGoneErr to Read or Write }
7518 kVCBFlagsHardwareGoneMask = $0020;
7519 kVCBFlagsVolumeDirtyBit = 15; { Set if volume information has changed since the last FlushVol }
7520 kVCBFlagsVolumeDirtyMask = $8000;
7521
7522 { ioVAtrb bits returned by PBHGetVInfo and PBXGetVolInfo }
7523 const
7524 kioVAtrbDefaultVolumeBit = 5; { Set if the volume is the default volume }
7525 kioVAtrbDefaultVolumeMask = $0020;
7526 kioVAtrbFilesOpenBit = 6; { Set if there are open files or iterators }
7527 kioVAtrbFilesOpenMask = $0040;
7528 kioVAtrbHardwareLockedBit = 7; { Set if volume is locked by a hardware setting }
7529 kioVAtrbHardwareLockedMask = $0080;
7530 kioVAtrbSoftwareLockedBit = 15; { Set if volume is locked by software }
7531 kioVAtrbSoftwareLockedMask = $8000;
7532
7533 { ioFlAttrib bits returned by PBGetCatInfo }
7534 const
7535 { file and directory attributes in ioFlAttrib }
7536 kioFlAttribLockedBit = 0; { Set if file or directory is locked }
7537 kioFlAttribLockedMask = $01;
7538 kioFlAttribResOpenBit = 2; { Set if resource fork is open }
7539 kioFlAttribResOpenMask = $04;
7540 kioFlAttribDataOpenBit = 3; { Set if data fork is open }
7541 kioFlAttribDataOpenMask = $08;
7542 kioFlAttribDirBit = 4; { Set if this is a directory }
7543 kioFlAttribDirMask = $10;
7544 ioDirFlg = 4; { Set if this is a directory (old name) }
7545 ioDirMask = $10;
7546 kioFlAttribCopyProtBit = 6; { Set if AppleShare server "copy-protects" the file }
7547 kioFlAttribCopyProtMask = $40;
7548 kioFlAttribFileOpenBit = 7; { Set if file (either fork) is open }
7549 kioFlAttribFileOpenMask = $80; { ioFlAttrib for directories only }
7550 kioFlAttribInSharedBit = 2; { Set if the directory is within a shared area of the directory hierarchy }
7551 kioFlAttribInSharedMask = $04;
7552 kioFlAttribMountedBit = 3; { Set if the directory is a share point that is mounted by some user }
7553 kioFlAttribMountedMask = $08;
7554 kioFlAttribSharePointBit = 5; { Set if the directory is a share point }
7555 kioFlAttribSharePointMask = $20;
7556
7557 { ioFCBFlags bits returned by PBGetFCBInfo }
7558 { IMPORTANT: These ioFCBFlags bit constants are for the SInt16 FCBPBRec.ioFCBFlags field returned }
7559 { by PBGetFCBInfoSync and PBGetFCBInfoAsync. Do not use them with the FSForkInfo.flags }
7560 { field returned by the FSGetForkCBInfo, PBGetForkCBInfoSync and PBGetForkCBInfoAsyn functions. }
7561 const
7562 kioFCBWriteBit = 8; { Data can be written to this file }
7563 kioFCBWriteMask = $0100;
7564 kioFCBResourceBit = 9; { This file is a resource fork }
7565 kioFCBResourceMask = $0200;
7566 kioFCBWriteLockedBit = 10; { File has a locked byte range }
7567 kioFCBWriteLockedMask = $0400;
7568 kioFCBLargeFileBit = 11; { File may grow beyond 2GB; cache uses file blocks, not bytes }
7569 kioFCBLargeFileMask = $0800;
7570 kioFCBSharedWriteBit = 12; { File is open for shared write access }
7571 kioFCBSharedWriteMask = $1000;
7572 kioFCBFileLockedBit = 13; { File is locked (write-protected) }
7573 kioFCBFileLockedMask = $2000;
7574 kioFCBOwnClumpBit = 14; { File has clump size specified in FCB }
7575 kioFCBOwnClumpMask = $4000;
7576 kioFCBModifiedBit = 15; { File has changed since it was last flushed }
7577 kioFCBModifiedMask = $8000;
7578
7579 { IMPORTANT: These FSForkInfoFlags constants are for use with the FSForkInfo.flags }
7580 { field returned by the FSGetForkCBInfo, PBGetForkCBInfoSync and PBGetForkCBInfoAsyn functions. }
7581 { Do not use them with the FCBPBRec.ioFCBFlags field returned by PBGetFCBInfoSync and PBGetFCBInfoAsync. }
7582 const
7583 kForkInfoFlagsWriteBit = kioFCBWriteBit - 8; { Data can be written to this file }
7584 kForkInfoFlagsWriteMask = 1 shl kForkInfoFlagsWriteBit;
7585 kForkInfoFlagsResourceBit = kioFCBResourceBit - 8; { This file is a resource fork }
7586 kForkInfoFlagsResourceMask = 1 shl kForkInfoFlagsResourceBit;
7587 kForkInfoFlagsWriteLockedBit = kioFCBWriteLockedBit - 8; { File has a locked byte range }
7588 kForkInfoFlagsWriteLockedMask = 1 shl kForkInfoFlagsWriteLockedBit;
7589 kForkInfoFlagsLargeFileBit = kioFCBLargeFileBit - 8; { File may grow beyond 2GB; cache uses file blocks, not bytes }
7590 kForkInfoFlagsLargeFileMask = 1 shl kForkInfoFlagsLargeFileBit;
7591 kForkInfoFlagsSharedWriteBit = kioFCBSharedWriteBit - 8; { File is open for shared write access }
7592 kForkInfoFlagsSharedWriteMask = 1 shl kForkInfoFlagsSharedWriteBit;
7593 kForkInfoFlagsFileLockedBit = kioFCBFileLockedBit - 8; { File is locked (write-protected) }
7594 kForkInfoFlagsFileLockedMask = 1 shl kForkInfoFlagsFileLockedBit;
7595 kForkInfoFlagsOwnClumpBit = kioFCBOwnClumpBit - 8; { File has clump size specified in FCB }
7596 kForkInfoFlagsOwnClumpMask = 1 shl kForkInfoFlagsOwnClumpBit;
7597 kForkInfoFlagsModifiedBit = kioFCBModifiedBit - 8; { File has changed since it was last flushed }
7598 kForkInfoFlagsModifiedMask = 1 shl kForkInfoFlagsModifiedBit;
7599
7600 { ioACUser bits returned by PBGetCatInfo }
7601 { Note: you must clear ioACUser before calling PBGetCatInfo because some file systems do not use this field }
7602 const
7603 kioACUserNoSeeFolderBit = 0; { Set if user does not have See Folder privileges }
7604 kioACUserNoSeeFolderMask = $01;
7605 kioACUserNoSeeFilesBit = 1; { Set if user does not have See Files privileges }
7606 kioACUserNoSeeFilesMask = $02;
7607 kioACUserNoMakeChangesBit = 2; { Set if user does not have Make Changes privileges }
7608 kioACUserNoMakeChangesMask = $04;
7609 kioACUserNotOwnerBit = 7; { Set if user is not owner of the directory }
7610 kioACUserNotOwnerMask = $80;
7611
7612 { Folder and File values of access privileges in ioACAccess }
7613 const
7614 kioACAccessOwnerBit = 31; { User is owner of directory }
7615 kioACAccessOwnerMask = -2147483648; { SInt32($80000000) }
7616 kioACAccessBlankAccessBit = 28; { Directory has blank access privileges }
7617 kioACAccessBlankAccessMask = $10000000;
7618 kioACAccessUserWriteBit = 26; { User has write privileges }
7619 kioACAccessUserWriteMask = $04000000;
7620 kioACAccessUserReadBit = 25; { User has read privileges }
7621 kioACAccessUserReadMask = $02000000;
7622 kioACAccessUserSearchBit = 24; { User has search privileges }
7623 kioACAccessUserSearchMask = $01000000;
7624 kioACAccessEveryoneWriteBit = 18; { Everyone has write privileges }
7625 kioACAccessEveryoneWriteMask = $00040000;
7626 kioACAccessEveryoneReadBit = 17; { Everyone has read privileges }
7627 kioACAccessEveryoneReadMask = $00020000;
7628 kioACAccessEveryoneSearchBit = 16; { Everyone has search privileges }
7629 kioACAccessEveryoneSearchMask = $00010000;
7630 kioACAccessGroupWriteBit = 10; { Group has write privileges }
7631 kioACAccessGroupWriteMask = $00000400;
7632 kioACAccessGroupReadBit = 9; { Group has read privileges }
7633 kioACAccessGroupReadMask = $00000200;
7634 kioACAccessGroupSearchBit = 8; { Group has search privileges }
7635 kioACAccessGroupSearchMask = $00000100;
7636 kioACAccessOwnerWriteBit = 2; { Owner has write privileges }
7637 kioACAccessOwnerWriteMask = $00000004;
7638 kioACAccessOwnerReadBit = 1; { Owner has read privileges }
7639 kioACAccessOwnerReadMask = $00000002;
7640 kioACAccessOwnerSearchBit = 0; { Owner has search privileges }
7641 kioACAccessOwnerSearchMask = $00000001;
7642 kfullPrivileges = $00070007; { all privileges for everybody and owner}
7643 kownerPrivileges = $00000007; { all privileges for owner only}
7644
7645
7646 { Volume Characteristics }
7647 {
7648 * FSGetVolumeParms()
7649 *
7650 * Discussion:
7651 * Returns information about the specified volume in the passed in
7652 * GetVolParmsInfoBuffer.
7653 *
7654 * Mac OS X threading:
7655 * Thread safe since version 10.5
7656 *
7657 * Parameters:
7658 *
7659 * volume:
7660 * The volume to get the information about.
7661 *
7662 * buffer:
7663 * A GetVolParmsInfoBuffer to fill out
7664 *
7665 * bufferSize:
7666 * the size of the passed in buffer
7667 *
7668 * Availability:
7669 * Mac OS X: in version 10.5 and later in CoreServices.framework
7670 * CarbonLib: not available in CarbonLib 1.x
7671 * Non-Carbon CFM: not available
7672 }
FSGetVolumeParmsnull7673 function FSGetVolumeParms( volume: FSVolumeRefNum; var buffer: GetVolParmsInfoBuffer; bufferSize: ByteCount ): OSStatus; external name '_FSGetVolumeParms';
7674 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7675
7676
7677 { VolumeMount }
7678 {
7679 * FSGetVolumeMountInfoSize()
7680 *
7681 * Discussion:
7682 * Returns the size of the MountInfo block associated with the
7683 * specified volume.
7684 *
7685 * Mac OS X threading:
7686 * Thread safe since version 10.5
7687 *
7688 * Parameters:
7689 *
7690 * volume:
7691 * The volume to get the MountInfo size for.
7692 *
7693 * size:
7694 * The size of the buffer required to store the MountInfo data
7695 *
7696 * Availability:
7697 * Mac OS X: in version 10.5 and later in CoreServices.framework
7698 * CarbonLib: not available in CarbonLib 1.x
7699 * Non-Carbon CFM: not available
7700 }
FSGetVolumeMountInfoSizenull7701 function FSGetVolumeMountInfoSize( volume: FSVolumeRefNum; var size: ByteCount ): OSStatus; external name '_FSGetVolumeMountInfoSize';
7702 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7703
7704
7705 {
7706 * FSGetVolumeMountInfo()
7707 *
7708 * Discussion:
7709 * Returns the MountInfo data for the specified volume. If the
7710 * buffer passed in is too small then errFSBadBuffer is returned and
7711 * actualSize will contain the required buffer size to hold the
7712 * MountInfo data.
7713 *
7714 * Mac OS X threading:
7715 * Thread safe since version 10.5
7716 *
7717 * Parameters:
7718 *
7719 * volume:
7720 * The volume to get the MountInfo for.
7721 *
7722 * buffer:
7723 * A pointer to the buffer to copy the MountInfo data into
7724 *
7725 * bufferSize:
7726 * The size of the buffer passed in
7727 *
7728 * actualSize:
7729 * The actual size of the MountInfo data
7730 *
7731 * Availability:
7732 * Mac OS X: in version 10.5 and later in CoreServices.framework
7733 * CarbonLib: not available in CarbonLib 1.x
7734 * Non-Carbon CFM: not available
7735 }
FSGetVolumeMountInfonull7736 function FSGetVolumeMountInfo( volume: FSVolumeRefNum; buffer: BytePtr; bufferSize: ByteCount; var actualSize: ByteCount ): OSStatus; external name '_FSGetVolumeMountInfo';
7737 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7738
7739
7740 {
7741 * FSVolumeMount()
7742 *
7743 * Discussion:
7744 * Will attempt to remount a volume using the passed in MountInfo
7745 * buffer
7746 *
7747 * Mac OS X threading:
7748 * Thread safe since version 10.5
7749 *
7750 * Parameters:
7751 *
7752 * buffer:
7753 * A pointer to the buffer with the MountInfo data.
7754 *
7755 * mountedVolume:
7756 * the FSVolumeRefNum of the volume that was mounted
7757 *
7758 * Availability:
7759 * Mac OS X: in version 10.5 and later in CoreServices.framework
7760 * CarbonLib: not available in CarbonLib 1.x
7761 * Non-Carbon CFM: not available
7762 }
FSVolumeMountnull7763 function FSVolumeMount( buffer: BytePtr; var mountedVolume: FSVolumeRefNum ): OSStatus; external name '_FSVolumeMount';
7764 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7765
7766
7767 { Volume flushing }
7768 {
7769 * FSFlushVolume()
7770 *
7771 * Mac OS X threading:
7772 * Thread safe since version 10.5
7773 *
7774 * Availability:
7775 * Mac OS X: in version 10.5 and later in CoreServices.framework
7776 * CarbonLib: not available in CarbonLib 1.x
7777 * Non-Carbon CFM: not available
7778 }
FSFlushVolumenull7779 function FSFlushVolume( vRefNum: FSVolumeRefNum ): OSStatus; external name '_FSFlushVolume';
7780 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7781
7782
7783 {
7784 * PBFlushVolumeSync()
7785 *
7786 * Mac OS X threading:
7787 * Thread safe since version 10.5
7788 *
7789 * Availability:
7790 * Mac OS X: in version 10.5 and later in CoreServices.framework
7791 * CarbonLib: not available in CarbonLib 1.x
7792 * Non-Carbon CFM: not available
7793 }
PBFlushVolumeSyncnull7794 function PBFlushVolumeSync( paramBlock: FSRefParamPtr ): OSStatus; external name '_PBFlushVolumeSync';
7795 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7796
7797
7798 {
7799 * PBFlushVolumeAsync()
7800 *
7801 * Mac OS X threading:
7802 * Thread safe since version 10.5
7803 *
7804 * Availability:
7805 * Mac OS X: in version 10.5 and later in CoreServices.framework
7806 * CarbonLib: not available in CarbonLib 1.x
7807 * Non-Carbon CFM: not available
7808 }
PBFlushVolumeAsyncnull7809 function PBFlushVolumeAsync( paramBlock: FSRefParamPtr ): OSStatus; external name '_PBFlushVolumeAsync';
7810 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7811
7812
7813 { CopyFile }
7814 {
7815 PBFSCopyFile
7816 Copies a file on a volume that supports the CopyFile system call (which can be
7817 determined from the bHasCopyFile GetVolParms bit).
7818 -> ioCompletion A pointer to a completion routine
7819 <- ioResult The result code of the function
7820 -> ref The source item to copy
7821 -> parentRef The destination to copy to
7822 -> nameLength Number of Unicode characters in the optional new name. Pass in 0 to use the source name
7823 -> name A pointer to the optional new Unicode name; Pass in NULL to use the source name
7824 <- newRef A pointer to the FSRef for the new object; may be NULL
7825 }
7826 {
7827 * PBFSCopyFileSync()
7828 *
7829 * Mac OS X threading:
7830 * Thread safe since version 10.5
7831 *
7832 * Availability:
7833 * Mac OS X: in version 10.5 and later in CoreServices.framework
7834 * CarbonLib: not available in CarbonLib 1.x
7835 * Non-Carbon CFM: not available
7836 }
PBFSCopyFileSyncnull7837 function PBFSCopyFileSync( paramBlock: FSRefParamPtr ): OSStatus; external name '_PBFSCopyFileSync';
7838 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7839
7840
7841 {
7842 * PBFSCopyFileAsync()
7843 *
7844 * Mac OS X threading:
7845 * Thread safe since version 10.5
7846 *
7847 * Availability:
7848 * Mac OS X: in version 10.5 and later in CoreServices.framework
7849 * CarbonLib: not available in CarbonLib 1.x
7850 * Non-Carbon CFM: not available
7851 }
PBFSCopyFileAsyncnull7852 function PBFSCopyFileAsync( paramBlock: FSRefParamPtr ): OSStatus; external name '_PBFSCopyFileAsync';
7853 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7854
7855
7856 { Node ID Resolution }
7857 {
7858 * FSResolveNodeID()
7859 *
7860 * Discussion:
7861 * Returns an FSRef to the item on volume with the specified node id.
7862 *
7863 * Mac OS X threading:
7864 * Thread safe since version 10.5
7865 *
7866 * Parameters:
7867 *
7868 * volume:
7869 * The FSVolumeRefNum of the volume the item is on
7870 *
7871 * nodeID:
7872 * The node id to resolve
7873 *
7874 * newRef:
7875 * A pointer to storage for the FSRef of the item with the
7876 * corresponding node id
7877 *
7878 * Availability:
7879 * Mac OS X: in version 10.5 and later in CoreServices.framework
7880 * CarbonLib: not available in CarbonLib 1.x
7881 * Non-Carbon CFM: not available
7882 }
FSResolveNodeIDnull7883 function FSResolveNodeID( volume: FSVolumeRefNum; nodeID: UInt32; newRef: FSRefPtr ): OSStatus; external name '_FSResolveNodeID';
7884 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7885
7886
7887 {
7888 -> ioCompletion A pointer to a completion routine
7889 <- ioResult The result code of the function
7890 -> ioVRefNum The FSVolumeRefNum of the volume the item is on
7891 -> ioDirID The node id to resolve (can be file as well as a directory node id)
7892 <- newRef A pointer to storage for the FSRef of the item with the corresponding node id
7893 }
7894 {
7895 * PBFSResolveNodeIDSync()
7896 *
7897 * Mac OS X threading:
7898 * Thread safe since version 10.5
7899 *
7900 * Availability:
7901 * Mac OS X: in version 10.5 and later in CoreServices.framework
7902 * CarbonLib: not available in CarbonLib 1.x
7903 * Non-Carbon CFM: not available
7904 }
PBFSResolveNodeIDSyncnull7905 function PBFSResolveNodeIDSync( paramBlock: FSRefParamPtr ): OSStatus; external name '_PBFSResolveNodeIDSync';
7906 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7907
7908
7909 {
7910 * PBFSResolveNodeIDAsync()
7911 *
7912 * Mac OS X threading:
7913 * Thread safe since version 10.5
7914 *
7915 * Availability:
7916 * Mac OS X: in version 10.5 and later in CoreServices.framework
7917 * CarbonLib: not available in CarbonLib 1.x
7918 * Non-Carbon CFM: not available
7919 }
PBFSResolveNodeIDAsyncnull7920 function PBFSResolveNodeIDAsync( paramBlock: FSRefParamPtr ): OSStatus; external name '_PBFSResolveNodeIDAsync';
7921 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_8, __IPHONE_NA, __IPHONE_NA) *)
7922
7923
7924 { Calls beyond this point are deprecated}
7925
7926 {
7927 MakeFSRef
7928 Create an FSRef for an existing object specified by a combination
7929 of volume refnum, parent directory, and pathname.
7930 -> ioCompletion A pointer to a completion routine
7931 <- ioResult The result code of the function
7932 -> ioNamePtr A pointer to a pathname
7933 -> ioVRefNum A volume specification
7934 -> ioDirID A directory ID
7935 <- newRef A pointer to an FSRef
7936 This function is deprecated in Mac OS X 10.5. Use FSMakeFSRefUnicode instead.
7937 }
7938 {$ifc not TARGET_CPU_64}
7939 {
7940 * FSpMakeFSRef() *** DEPRECATED ***
7941 *
7942 * Mac OS X threading:
7943 * Thread safe since version 10.0
7944 *
7945 * Availability:
7946 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
7947 * CarbonLib: in CarbonLib 1.0 and later
7948 * Non-Carbon CFM: in InterfaceLib 9.0 and later
7949 }
FSpMakeFSRefnull7950 function FSpMakeFSRef( const (*var*) source: FSSpec; var newRef: FSRef ): OSErr; external name '_FSpMakeFSRef';
7951 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
7952
7953
7954 { This function is deprecated in Mac OS X 10.5. Use PBMakeFSRefUnicodeSync instead.}
7955 {
7956 * PBMakeFSRefSync() *** DEPRECATED ***
7957 *
7958 * Mac OS X threading:
7959 * Thread safe since version 10.0
7960 *
7961 * Availability:
7962 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
7963 * CarbonLib: in CarbonLib 1.0 and later
7964 * Non-Carbon CFM: in InterfaceLib 9.0 and later
7965 }
PBMakeFSRefSyncnull7966 function PBMakeFSRefSync( var paramBlock: FSRefParam ): OSErr; external name '_PBMakeFSRefSync';
7967 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
7968
7969
7970 { This function is deprecated in Mac OS X 10.5. Use PBMakeFSRefUnicodeAsync instead.}
7971 {
7972 * PBMakeFSRefAsync() *** DEPRECATED ***
7973 *
7974 * Mac OS X threading:
7975 * Thread safe since version 10.0
7976 *
7977 * Availability:
7978 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
7979 * CarbonLib: in CarbonLib 1.0 and later
7980 * Non-Carbon CFM: in InterfaceLib 9.0 and later
7981 }
7982 procedure PBMakeFSRefAsync( var paramBlock: FSRefParam ); external name '_PBMakeFSRefAsync';
7983 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
7984
7985
7986 { This function is deprecated in Mac OS X 10.5. Use PBCloseForkSync instead.}
7987 {
7988 * PBCloseSync() *** DEPRECATED ***
7989 *
7990 * Availability:
7991 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
7992 * CarbonLib: in CarbonLib 1.0 and later
7993 * Non-Carbon CFM: in InterfaceLib 7.1 and later
7994 }
PBCloseSyncnull7995 function PBCloseSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBCloseSync';
7996 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
7997
7998
7999 { This function is deprecated in Mac OS X 10.5. Use PBCloseForkAsync instead.}
8000 {
8001 * PBCloseAsync() *** DEPRECATED ***
8002 *
8003 * Availability:
8004 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8005 * CarbonLib: in CarbonLib 1.0 and later
8006 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8007 }
PBCloseAsyncnull8008 function PBCloseAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBCloseAsync';
8009 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8010
8011
8012 { This function is deprecated in Mac OS X 10.5. Use PBReadForkSync instead.}
8013 {
8014 * PBReadSync() *** DEPRECATED ***
8015 *
8016 * Availability:
8017 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8018 * CarbonLib: in CarbonLib 1.0 and later
8019 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8020 }
PBReadSyncnull8021 function PBReadSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBReadSync';
8022 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8023
8024
8025 { This function is deprecated in Mac OS X 10.5. Use PBReadForkAsync instead.}
8026 {
8027 * PBReadAsync() *** DEPRECATED ***
8028 *
8029 * Availability:
8030 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8031 * CarbonLib: in CarbonLib 1.0 and later
8032 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8033 }
PBReadAsyncnull8034 function PBReadAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBReadAsync';
8035 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8036
8037
8038 { This function is deprecated in Mac OS X 10.5. Use PBWriteForkSync instead.}
8039 {
8040 * PBWriteSync() *** DEPRECATED ***
8041 *
8042 * Availability:
8043 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8044 * CarbonLib: in CarbonLib 1.0 and later
8045 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8046 }
PBWriteSyncnull8047 function PBWriteSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBWriteSync';
8048 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8049
8050
8051 { This function is deprecated in Mac OS X 10.5. Use PBWriteForkAsync instead.}
8052 {
8053 * PBWriteAsync() *** DEPRECATED ***
8054 *
8055 * Availability:
8056 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8057 * CarbonLib: in CarbonLib 1.0 and later
8058 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8059 }
PBWriteAsyncnull8060 function PBWriteAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBWriteAsync';
8061 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8062
8063
8064 { This function is deprecated in Mac OS X 10.5. It was never implemented on OS X.}
8065 {
8066 * PBWaitIOComplete() *** DEPRECATED ***
8067 *
8068 * Availability:
8069 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8070 * CarbonLib: in CarbonLib 1.0 and later
8071 * Non-Carbon CFM: in InterfaceLib 9.0 and later
8072 }
PBWaitIOCompletenull8073 function PBWaitIOComplete( paramBlock: ParmBlkPtr; timeout: Duration ): OSErr; external name '_PBWaitIOComplete';
8074 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8075
8076
8077 { Volume Characteristics }
8078 { This function is deprecated in Mac OS X 10.5. Use FSGetVolumeParms instead.}
8079 {
8080 * PBHGetVolParmsSync() *** DEPRECATED ***
8081 *
8082 * Mac OS X threading:
8083 * Thread safe since version 10.0
8084 *
8085 * Availability:
8086 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8087 * CarbonLib: in CarbonLib 1.0 and later
8088 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8089 }
PBHGetVolParmsSyncnull8090 function PBHGetVolParmsSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetVolParmsSync';
8091 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8092
8093
8094 { This function is deprecated in Mac OS X 10.5. Use FSGetVolumeParms instead.}
8095 {
8096 * PBHGetVolParmsAsync() *** DEPRECATED ***
8097 *
8098 * Mac OS X threading:
8099 * Thread safe since version 10.0
8100 *
8101 * Availability:
8102 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8103 * CarbonLib: in CarbonLib 1.0 and later
8104 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8105 }
PBHGetVolParmsAsyncnull8106 function PBHGetVolParmsAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetVolParmsAsync';
8107 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8108
8109
8110 { VolumeMount }
8111 { This function is deprecated in Mac OS X 10.5. Use FSGetVolumeMountInfoSize instead.}
8112 {
8113 * PBGetVolMountInfoSize() *** DEPRECATED ***
8114 *
8115 * Mac OS X threading:
8116 * Thread safe since version 10.0
8117 *
8118 * Availability:
8119 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8120 * CarbonLib: in CarbonLib 1.0 and later
8121 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8122 }
PBGetVolMountInfoSizenull8123 function PBGetVolMountInfoSize( paramBlock: ParmBlkPtr ): OSErr; external name '_PBGetVolMountInfoSize';
8124 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8125
8126
8127 { This function is deprecated in Mac OS X 10.5. Use FSGetVolumeMountInfo instead.}
8128 {
8129 * PBGetVolMountInfo() *** DEPRECATED ***
8130 *
8131 * Mac OS X threading:
8132 * Thread safe since version 10.0
8133 *
8134 * Availability:
8135 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8136 * CarbonLib: in CarbonLib 1.0 and later
8137 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8138 }
PBGetVolMountInfonull8139 function PBGetVolMountInfo( paramBlock: ParmBlkPtr ): OSErr; external name '_PBGetVolMountInfo';
8140 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8141
8142
8143 { This function is deprecated in Mac OS X 10.5. Use FSVolumeMount instead.}
8144 {
8145 * PBVolumeMount() *** DEPRECATED ***
8146 *
8147 * Availability:
8148 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8149 * CarbonLib: in CarbonLib 1.0 and later
8150 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8151 }
PBVolumeMountnull8152 function PBVolumeMount( paramBlock: ParmBlkPtr ): OSErr; external name '_PBVolumeMount';
8153 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8154
8155
8156 { Volume flushing }
8157 { This function is deprecated in Mac OS X 10.5. Use FSFlushVolume instead.}
8158 {
8159 * FlushVol() *** DEPRECATED ***
8160 *
8161 * Mac OS X threading:
8162 * Thread safe since version 10.0
8163 *
8164 * Availability:
8165 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8166 * CarbonLib: in CarbonLib 1.0 and later
8167 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8168 }
FlushVolnull8169 function FlushVol( volName: ConstStr63Param; vRefNum: FSVolumeRefNum ): OSErr; external name '_FlushVol';
8170 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8171
8172
8173 { This function is deprecated in Mac OS X 10.5. Use PBFlushVolumeSync instead.}
8174 {
8175 * PBFlushVolSync() *** DEPRECATED ***
8176 *
8177 * Mac OS X threading:
8178 * Thread safe since version 10.0
8179 *
8180 * Availability:
8181 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8182 * CarbonLib: in CarbonLib 1.0 and later
8183 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8184 }
PBFlushVolSyncnull8185 function PBFlushVolSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBFlushVolSync';
8186 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8187
8188
8189 { This function is deprecated in Mac OS X 10.5. Use PBFlushVolumeAsync instead.}
8190 {
8191 * PBFlushVolAsync() *** DEPRECATED ***
8192 *
8193 * Mac OS X threading:
8194 * Thread safe since version 10.0
8195 *
8196 * Availability:
8197 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8198 * CarbonLib: in CarbonLib 1.0 and later
8199 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8200 }
PBFlushVolAsyncnull8201 function PBFlushVolAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBFlushVolAsync';
8202 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8203
8204
8205 { This function is deprecated in Mac OS X 10.5. Use PBOpenForkSync with deny pos modes instead.}
8206 {
8207 * PBHOpenDenySync() *** DEPRECATED ***
8208 *
8209 * Mac OS X threading:
8210 * Thread safe since version 10.0
8211 *
8212 * Availability:
8213 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8214 * CarbonLib: in CarbonLib 1.0 and later
8215 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8216 }
PBHOpenDenySyncnull8217 function PBHOpenDenySync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenDenySync';
8218 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8219
8220
8221 { This function is deprecated in Mac OS X 10.5. Use PBOpenForkAsync with deny pos modes instead.}
8222 {
8223 * PBHOpenDenyAsync() *** DEPRECATED ***
8224 *
8225 * Mac OS X threading:
8226 * Thread safe since version 10.0
8227 *
8228 * Availability:
8229 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8230 * CarbonLib: in CarbonLib 1.0 and later
8231 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8232 }
PBHOpenDenyAsyncnull8233 function PBHOpenDenyAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenDenyAsync';
8234 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8235
8236
8237 { This function is deprecated in Mac OS X 10.5. Use PBOpenForkSync with deny pos modes instead.}
8238 {
8239 * PBHOpenRFDenySync() *** DEPRECATED ***
8240 *
8241 * Mac OS X threading:
8242 * Thread safe since version 10.0
8243 *
8244 * Availability:
8245 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8246 * CarbonLib: in CarbonLib 1.0 and later
8247 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8248 }
PBHOpenRFDenySyncnull8249 function PBHOpenRFDenySync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenRFDenySync';
8250 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8251
8252
8253 { This function is deprecated in Mac OS X 10.5. Use PBOpenForkAsync with deny pos modes instead.}
8254 {
8255 * PBHOpenRFDenyAsync() *** DEPRECATED ***
8256 *
8257 * Mac OS X threading:
8258 * Thread safe since version 10.0
8259 *
8260 * Availability:
8261 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8262 * CarbonLib: in CarbonLib 1.0 and later
8263 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8264 }
PBHOpenRFDenyAsyncnull8265 function PBHOpenRFDenyAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenRFDenyAsync';
8266 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8267
8268
8269 { This function is deprecated in Mac OS X 10.5. Use FSGetCatalogInfo instead.}
8270 {
8271 * PBHGetDirAccessSync() *** DEPRECATED ***
8272 *
8273 * Mac OS X threading:
8274 * Thread safe since version 10.0
8275 *
8276 * Availability:
8277 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8278 * CarbonLib: in CarbonLib 1.0 and later
8279 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8280 }
PBHGetDirAccessSyncnull8281 function PBHGetDirAccessSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetDirAccessSync';
8282 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8283
8284
8285 { This function is deprecated in Mac OS X 10.5. Use FSGetCatalogInfo instead.}
8286 {
8287 * PBHGetDirAccessAsync() *** DEPRECATED ***
8288 *
8289 * Mac OS X threading:
8290 * Thread safe since version 10.0
8291 *
8292 * Availability:
8293 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8294 * CarbonLib: in CarbonLib 1.0 and later
8295 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8296 }
PBHGetDirAccessAsyncnull8297 function PBHGetDirAccessAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetDirAccessAsync';
8298 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8299
8300
8301 { This function is deprecated in Mac OS X 10.5. Use FSSetCatalogInfo instead.}
8302 {
8303 * PBHSetDirAccessSync() *** DEPRECATED ***
8304 *
8305 * Mac OS X threading:
8306 * Thread safe since version 10.0
8307 *
8308 * Availability:
8309 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8310 * CarbonLib: in CarbonLib 1.0 and later
8311 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8312 }
PBHSetDirAccessSyncnull8313 function PBHSetDirAccessSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHSetDirAccessSync';
8314 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8315
8316
8317 { This function is deprecated in Mac OS X 10.5. Use FSSetCatalogInfo instead.}
8318 {
8319 * PBHSetDirAccessAsync() *** DEPRECATED ***
8320 *
8321 * Mac OS X threading:
8322 * Thread safe since version 10.0
8323 *
8324 * Availability:
8325 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8326 * CarbonLib: in CarbonLib 1.0 and later
8327 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8328 }
PBHSetDirAccessAsyncnull8329 function PBHSetDirAccessAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHSetDirAccessAsync';
8330 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8331
8332
8333 { This function is deprecated in Mac OS X 10.5. See getpwnam() and getpwuid().}
8334 {
8335 * PBHMapIDSync() *** DEPRECATED ***
8336 *
8337 * Mac OS X threading:
8338 * Thread safe since version 10.0
8339 *
8340 * Availability:
8341 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8342 * CarbonLib: in CarbonLib 1.0 and later
8343 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8344 }
PBHMapIDSyncnull8345 function PBHMapIDSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHMapIDSync';
8346 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8347
8348
8349 { This function is deprecated in Mac OS X 10.5. See getpwnam() and getpwuid().}
8350 {
8351 * PBHMapIDAsync() *** DEPRECATED ***
8352 *
8353 * Mac OS X threading:
8354 * Thread safe since version 10.0
8355 *
8356 * Availability:
8357 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8358 * CarbonLib: in CarbonLib 1.0 and later
8359 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8360 }
PBHMapIDAsyncnull8361 function PBHMapIDAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHMapIDAsync';
8362 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8363
8364
8365 { This function is deprecated in Mac OS X 10.5. See getpwnam() and getpwuid().}
8366 {
8367 * PBHMapNameSync() *** DEPRECATED ***
8368 *
8369 * Mac OS X threading:
8370 * Thread safe since version 10.0
8371 *
8372 * Availability:
8373 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8374 * CarbonLib: in CarbonLib 1.0 and later
8375 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8376 }
PBHMapNameSyncnull8377 function PBHMapNameSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHMapNameSync';
8378 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8379
8380
8381 { This function is deprecated in Mac OS X 10.5. See getpwnam() and getpwuid().}
8382 {
8383 * PBHMapNameAsync() *** DEPRECATED ***
8384 *
8385 * Mac OS X threading:
8386 * Thread safe since version 10.0
8387 *
8388 * Availability:
8389 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8390 * CarbonLib: in CarbonLib 1.0 and later
8391 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8392 }
PBHMapNameAsyncnull8393 function PBHMapNameAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHMapNameAsync';
8394 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8395
8396
8397 { This function is deprecated in Mac OS X 10.5. Use PBFSCopyFileSync instead.}
8398 {
8399 * PBHCopyFileSync() *** DEPRECATED ***
8400 *
8401 * Mac OS X threading:
8402 * Thread safe since version 10.0
8403 *
8404 * Availability:
8405 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8406 * CarbonLib: in CarbonLib 1.0 and later
8407 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8408 }
PBHCopyFileSyncnull8409 function PBHCopyFileSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHCopyFileSync';
8410 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8411
8412
8413 { This function is deprecated in Mac OS X 10.5. Use PBFSCopyFileAsync instead.}
8414 {
8415 * PBHCopyFileAsync() *** DEPRECATED ***
8416 *
8417 * Mac OS X threading:
8418 * Thread safe since version 10.0
8419 *
8420 * Availability:
8421 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8422 * CarbonLib: in CarbonLib 1.0 and later
8423 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8424 }
PBHCopyFileAsyncnull8425 function PBHCopyFileAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHCopyFileAsync';
8426 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8427
8428
8429 { This function is deprecated in Mac OS X 10.5. Use FSGetCatalogInfo to get the node id.}
8430 {
8431 * PBCreateFileIDRefSync() *** DEPRECATED ***
8432 *
8433 * Mac OS X threading:
8434 * Thread safe since version 10.0
8435 *
8436 * Availability:
8437 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8438 * CarbonLib: in CarbonLib 1.0 and later
8439 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8440 }
PBCreateFileIDRefSyncnull8441 function PBCreateFileIDRefSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBCreateFileIDRefSync';
8442 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8443
8444
8445 { This function is deprecated in Mac OS X 10.5. Use FSGetCatalogInfo to get the node id.}
8446 {
8447 * PBCreateFileIDRefAsync() *** DEPRECATED ***
8448 *
8449 * Mac OS X threading:
8450 * Thread safe since version 10.0
8451 *
8452 * Availability:
8453 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8454 * CarbonLib: in CarbonLib 1.0 and later
8455 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8456 }
PBCreateFileIDRefAsyncnull8457 function PBCreateFileIDRefAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBCreateFileIDRefAsync';
8458 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8459
8460
8461 { This function is deprecated in Mac OS X 10.5. Use FSGetCatalogInfo to get the node id.}
8462 {
8463 * PBResolveFileIDRefSync() *** DEPRECATED ***
8464 *
8465 * Mac OS X threading:
8466 * Thread safe since version 10.0
8467 *
8468 * Availability:
8469 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8470 * CarbonLib: in CarbonLib 1.0 and later
8471 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8472 }
PBResolveFileIDRefSyncnull8473 function PBResolveFileIDRefSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBResolveFileIDRefSync';
8474 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8475
8476
8477 { This function is deprecated in Mac OS X 10.5. Use FSGetCatalogInfo to get the node id.}
8478 {
8479 * PBResolveFileIDRefAsync() *** DEPRECATED ***
8480 *
8481 * Mac OS X threading:
8482 * Thread safe since version 10.0
8483 *
8484 * Availability:
8485 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8486 * CarbonLib: in CarbonLib 1.0 and later
8487 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8488 }
PBResolveFileIDRefAsyncnull8489 function PBResolveFileIDRefAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBResolveFileIDRefAsync';
8490 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8491
8492
8493 { This function is deprecated in Mac OS X 10.5. It is obsolete and has no replacement.}
8494 {
8495 * PBDeleteFileIDRefSync() *** DEPRECATED ***
8496 *
8497 * Mac OS X threading:
8498 * Thread safe since version 10.0
8499 *
8500 * Availability:
8501 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8502 * CarbonLib: in CarbonLib 1.0 and later
8503 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8504 }
PBDeleteFileIDRefSyncnull8505 function PBDeleteFileIDRefSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBDeleteFileIDRefSync';
8506 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8507
8508
8509 { This function is deprecated in Mac OS X 10.5. It is obsolete and has no replacement.}
8510 {
8511 * PBDeleteFileIDRefAsync() *** DEPRECATED ***
8512 *
8513 * Mac OS X threading:
8514 * Thread safe since version 10.0
8515 *
8516 * Availability:
8517 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.5
8518 * CarbonLib: in CarbonLib 1.0 and later
8519 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8520 }
PBDeleteFileIDRefAsyncnull8521 function PBDeleteFileIDRefAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBDeleteFileIDRefAsync';
8522 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_5, __IPHONE_NA, __IPHONE_NA) *)
8523
8524
8525 { This function is deprecated in Mac OS X 10.4. Use FSGetVolumeInfo instead.}
8526 {
8527 * PBXGetVolInfoSync() *** DEPRECATED ***
8528 *
8529 * Mac OS X threading:
8530 * Thread safe since version 10.0
8531 *
8532 * Availability:
8533 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8534 * CarbonLib: in CarbonLib 1.0 and later
8535 * Non-Carbon CFM: in InterfaceLib 8.5 and later
8536 }
PBXGetVolInfoSyncnull8537 function PBXGetVolInfoSync( paramBlock: XVolumeParamPtr ): OSErr; external name '_PBXGetVolInfoSync';
8538 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8539
8540
8541 { This function is deprecated in Mac OS X 10.4. Use FSGetVolumeInfo instead.}
8542 {
8543 * PBXGetVolInfoAsync() *** DEPRECATED ***
8544 *
8545 * Mac OS X threading:
8546 * Thread safe since version 10.0
8547 *
8548 * Availability:
8549 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8550 * CarbonLib: in CarbonLib 1.0 and later
8551 * Non-Carbon CFM: in InterfaceLib 8.5 and later
8552 }
PBXGetVolInfoAsyncnull8553 function PBXGetVolInfoAsync( paramBlock: XVolumeParamPtr ): OSErr; external name '_PBXGetVolInfoAsync';
8554 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8555
8556
8557 { This function is deprecated in Mac OS X 10.4. Use PBAllocateForkSync instead.}
8558 {
8559 * PBAllocateSync() *** DEPRECATED ***
8560 *
8561 * Mac OS X threading:
8562 * Thread safe since version 10.0
8563 *
8564 * Availability:
8565 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8566 * CarbonLib: in CarbonLib 1.0 and later
8567 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8568 }
PBAllocateSyncnull8569 function PBAllocateSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBAllocateSync';
8570 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8571
8572
8573 { This function is deprecated in Mac OS X 10.4. Use PBAllocateForkAsync instead.}
8574 {
8575 * PBAllocateAsync() *** DEPRECATED ***
8576 *
8577 * Mac OS X threading:
8578 * Thread safe since version 10.0
8579 *
8580 * Availability:
8581 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8582 * CarbonLib: in CarbonLib 1.0 and later
8583 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8584 }
PBAllocateAsyncnull8585 function PBAllocateAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBAllocateAsync';
8586 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8587
8588
8589 { This function is deprecated in Mac OS X 10.4. Use PBGetForkSizeSync instead.}
8590 {
8591 * PBGetEOFSync() *** DEPRECATED ***
8592 *
8593 * Mac OS X threading:
8594 * Thread safe since version 10.0
8595 *
8596 * Availability:
8597 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8598 * CarbonLib: in CarbonLib 1.0 and later
8599 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8600 }
PBGetEOFSyncnull8601 function PBGetEOFSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBGetEOFSync';
8602 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8603
8604
8605 { This function is deprecated in Mac OS X 10.4. Use PBGetForkSizeAsync instead.}
8606 {
8607 * PBGetEOFAsync() *** DEPRECATED ***
8608 *
8609 * Mac OS X threading:
8610 * Thread safe since version 10.0
8611 *
8612 * Availability:
8613 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8614 * CarbonLib: in CarbonLib 1.0 and later
8615 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8616 }
PBGetEOFAsyncnull8617 function PBGetEOFAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBGetEOFAsync';
8618 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8619
8620
8621 { This function is deprecated in Mac OS X 10.4. Use PBSetForkSizeSync instead.}
8622 {
8623 * PBSetEOFSync() *** DEPRECATED ***
8624 *
8625 * Mac OS X threading:
8626 * Thread safe since version 10.0
8627 *
8628 * Availability:
8629 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8630 * CarbonLib: in CarbonLib 1.0 and later
8631 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8632 }
PBSetEOFSyncnull8633 function PBSetEOFSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBSetEOFSync';
8634 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8635
8636
8637 { This function is deprecated in Mac OS X 10.4. Use PBSetForkSizeAsync instead.}
8638 {
8639 * PBSetEOFAsync() *** DEPRECATED ***
8640 *
8641 * Mac OS X threading:
8642 * Thread safe since version 10.0
8643 *
8644 * Availability:
8645 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8646 * CarbonLib: in CarbonLib 1.0 and later
8647 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8648 }
PBSetEOFAsyncnull8649 function PBSetEOFAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBSetEOFAsync';
8650 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8651
8652
8653 { This function is deprecated in Mac OS X 10.4. Use PBGetForkPositionSync instead.}
8654 {
8655 * PBGetFPosSync() *** DEPRECATED ***
8656 *
8657 * Mac OS X threading:
8658 * Thread safe since version 10.0
8659 *
8660 * Availability:
8661 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8662 * CarbonLib: in CarbonLib 1.0 and later
8663 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8664 }
PBGetFPosSyncnull8665 function PBGetFPosSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBGetFPosSync';
8666 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8667
8668
8669 { This function is deprecated in Mac OS X 10.4. Use PBGetForkPositionAsync instead.}
8670 {
8671 * PBGetFPosAsync() *** DEPRECATED ***
8672 *
8673 * Mac OS X threading:
8674 * Thread safe since version 10.0
8675 *
8676 * Availability:
8677 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8678 * CarbonLib: in CarbonLib 1.0 and later
8679 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8680 }
PBGetFPosAsyncnull8681 function PBGetFPosAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBGetFPosAsync';
8682 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8683
8684
8685 { This function is deprecated in Mac OS X 10.4. Use PBSetForkPositionSync instead.}
8686 {
8687 * PBSetFPosSync() *** DEPRECATED ***
8688 *
8689 * Mac OS X threading:
8690 * Thread safe since version 10.0
8691 *
8692 * Availability:
8693 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8694 * CarbonLib: in CarbonLib 1.0 and later
8695 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8696 }
PBSetFPosSyncnull8697 function PBSetFPosSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBSetFPosSync';
8698 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8699
8700
8701 { This function is deprecated in Mac OS X 10.4. Use PBSetForkPositionAsync instead.}
8702 {
8703 * PBSetFPosAsync() *** DEPRECATED ***
8704 *
8705 * Mac OS X threading:
8706 * Thread safe since version 10.0
8707 *
8708 * Availability:
8709 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8710 * CarbonLib: in CarbonLib 1.0 and later
8711 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8712 }
PBSetFPosAsyncnull8713 function PBSetFPosAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBSetFPosAsync';
8714 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8715
8716
8717 { This function is deprecated in Mac OS X 10.4. Use PBFlushForkSync instead.}
8718 {
8719 * PBFlushFileSync() *** DEPRECATED ***
8720 *
8721 * Mac OS X threading:
8722 * Thread safe since version 10.0
8723 *
8724 * Availability:
8725 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8726 * CarbonLib: in CarbonLib 1.0 and later
8727 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8728 }
PBFlushFileSyncnull8729 function PBFlushFileSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBFlushFileSync';
8730 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8731
8732
8733 { This function is deprecated in Mac OS X 10.4. Use PBFlushForkAsync instead.}
8734 {
8735 * PBFlushFileAsync() *** DEPRECATED ***
8736 *
8737 * Mac OS X threading:
8738 * Thread safe since version 10.0
8739 *
8740 * Availability:
8741 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8742 * CarbonLib: in CarbonLib 1.0 and later
8743 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8744 }
PBFlushFileAsyncnull8745 function PBFlushFileAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBFlushFileAsync';
8746 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8747
8748
8749 { This function is deprecated in Mac OS X 10.4. Use FSEjectVolumeSync instead.}
8750 {
8751 * PBUnmountVol() *** DEPRECATED ***
8752 *
8753 * Mac OS X threading:
8754 * Thread safe since version 10.0
8755 *
8756 * Availability:
8757 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8758 * CarbonLib: in CarbonLib 1.0 and later
8759 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8760 }
PBUnmountVolnull8761 function PBUnmountVol( paramBlock: ParmBlkPtr ): OSErr; external name '_PBUnmountVol';
8762 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8763
8764
8765 { This function is deprecated in Mac OS X 10.4. Use PBCatalogSearchSync instead.}
8766 {
8767 * PBCatSearchSync() *** DEPRECATED ***
8768 *
8769 * Mac OS X threading:
8770 * Thread safe since version 10.0
8771 *
8772 * Availability:
8773 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8774 * CarbonLib: in CarbonLib 1.0 and later
8775 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8776 }
PBCatSearchSyncnull8777 function PBCatSearchSync( paramBlock: CSParamPtr ): OSErr; external name '_PBCatSearchSync';
8778 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8779
8780
8781 { This function is deprecated in Mac OS X 10.4. Use PBCatalogSearchAsync instead.}
8782 {
8783 * PBCatSearchAsync() *** DEPRECATED ***
8784 *
8785 * Mac OS X threading:
8786 * Thread safe since version 10.0
8787 *
8788 * Availability:
8789 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8790 * CarbonLib: in CarbonLib 1.0 and later
8791 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8792 }
PBCatSearchAsyncnull8793 function PBCatSearchAsync( paramBlock: CSParamPtr ): OSErr; external name '_PBCatSearchAsync';
8794 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8795
8796
8797 { This function is deprecated in Mac OS X 10.4. Use FSEjectVolumeSync instead.}
8798 {
8799 * UnmountVol() *** DEPRECATED ***
8800 *
8801 * Mac OS X threading:
8802 * Thread safe since version 10.0
8803 *
8804 * Availability:
8805 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8806 * CarbonLib: in CarbonLib 1.0 and later
8807 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8808 }
UnmountVolnull8809 function UnmountVol( volName: ConstStringPtr { can be NULL }; vRefNum: FSVolumeRefNum ): OSErr; external name '_UnmountVol';
8810 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8811
8812
8813 { This function is deprecated in Mac OS X 10.4. The routines which use the default volume concept have been deprecated.}
8814 {
8815 * HSetVol() *** DEPRECATED ***
8816 *
8817 * Mac OS X threading:
8818 * Thread safe since version 10.0
8819 *
8820 * Availability:
8821 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8822 * CarbonLib: in CarbonLib 1.0 and later
8823 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8824 }
HSetVolnull8825 function HSetVol( volName: ConstStringPtr { can be NULL }; vRefNum: FSVolumeRefNum; dirID: SInt32 ): OSErr; external name '_HSetVol';
8826 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8827
8828
8829 { AddDrive() was moved to Devices.h}
8830
8831 { This function is deprecated in Mac OS X 10.4. Use FSCloseFork instead.}
8832 {
8833 * FSClose() *** DEPRECATED ***
8834 *
8835 * Mac OS X threading:
8836 * Thread safe since version 10.0
8837 *
8838 * Availability:
8839 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8840 * CarbonLib: in CarbonLib 1.0 and later
8841 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8842 }
FSClosenull8843 function FSClose( refNum: FSIORefNum ): OSErr; external name '_FSClose';
8844 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8845
8846
8847 { This function is deprecated in Mac OS X 10.4. Use FSReadFork instead.}
8848 {
8849 * FSRead() *** DEPRECATED ***
8850 *
8851 * Mac OS X threading:
8852 * Thread safe since version 10.0
8853 *
8854 * Availability:
8855 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8856 * CarbonLib: in CarbonLib 1.0 and later
8857 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8858 }
FSReadnull8859 function FSRead( refNum: FSIORefNum; var count: SInt32; buffPtr: UnivPtr ): OSErr; external name '_FSRead';
8860 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8861
8862
8863 { This function is deprecated in Mac OS X 10.4. Use FSWriteFork instead.}
8864 {
8865 * FSWrite() *** DEPRECATED ***
8866 *
8867 * Mac OS X threading:
8868 * Thread safe since version 10.0
8869 *
8870 * Availability:
8871 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8872 * CarbonLib: in CarbonLib 1.0 and later
8873 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8874 }
FSWritenull8875 function FSWrite( refNum: FSIORefNum; var count: SInt32; buffPtr: {const} UnivPtr ): OSErr; external name '_FSWrite';
8876 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8877
8878
8879 { This function is deprecated in Mac OS X 10.4. Use FSAllocateFork instead.}
8880 {
8881 * Allocate() *** DEPRECATED ***
8882 *
8883 * Mac OS X threading:
8884 * Thread safe since version 10.0
8885 *
8886 * Availability:
8887 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8888 * CarbonLib: in CarbonLib 1.0 and later
8889 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8890 }
Allocatenull8891 function Allocate( refNum: FSIORefNum; var count: SInt32 ): OSErr; external name '_Allocate';
8892 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8893
8894
8895 { This function is deprecated in Mac OS X 10.4. Use FSGetForkSize instead.}
8896 {
8897 * GetEOF() *** DEPRECATED ***
8898 *
8899 * Mac OS X threading:
8900 * Thread safe since version 10.0
8901 *
8902 * Availability:
8903 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8904 * CarbonLib: in CarbonLib 1.0 and later
8905 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8906 }
GetEOFnull8907 function GetEOF( refNum: FSIORefNum; var logEOF: SInt32 ): OSErr; external name '_GetEOF';
8908 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8909
8910
8911 { This function is deprecated in Mac OS X 10.4. Use FSSetForkSize instead.}
8912 {
8913 * SetEOF() *** DEPRECATED ***
8914 *
8915 * Mac OS X threading:
8916 * Thread safe since version 10.0
8917 *
8918 * Availability:
8919 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8920 * CarbonLib: in CarbonLib 1.0 and later
8921 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8922 }
SetEOFnull8923 function SetEOF( refNum: FSIORefNum; logEOF: SInt32 ): OSErr; external name '_SetEOF';
8924 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8925
8926
8927 { This function is deprecated in Mac OS X 10.4. Use FSGetForkPosition instead.}
8928 {
8929 * GetFPos() *** DEPRECATED ***
8930 *
8931 * Mac OS X threading:
8932 * Thread safe since version 10.0
8933 *
8934 * Availability:
8935 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8936 * CarbonLib: in CarbonLib 1.0 and later
8937 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8938 }
GetFPosnull8939 function GetFPos( refNum: FSIORefNum; var filePos: SInt32 ): OSErr; external name '_GetFPos';
8940 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8941
8942
8943 { This function is deprecated in Mac OS X 10.4. Use FSSetForkPosition instead.}
8944 {
8945 * SetFPos() *** DEPRECATED ***
8946 *
8947 * Mac OS X threading:
8948 * Thread safe since version 10.0
8949 *
8950 * Availability:
8951 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8952 * CarbonLib: in CarbonLib 1.0 and later
8953 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8954 }
SetFPosnull8955 function SetFPos( refNum: FSIORefNum; posMode: SInt16; posOff: SInt32 ): OSErr; external name '_SetFPos';
8956 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8957
8958
8959 { This function is deprecated in Mac OS X 10.4. Use FSGetCatalogInfo instead.}
8960 {
8961 * GetVRefNum() *** DEPRECATED ***
8962 *
8963 * Mac OS X threading:
8964 * Thread safe since version 10.0
8965 *
8966 * Availability:
8967 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8968 * CarbonLib: in CarbonLib 1.0 and later
8969 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8970 }
GetVRefNumnull8971 function GetVRefNum( fileRefNum: FSIORefNum; var vRefNum: FSVolumeRefNum ): OSErr; external name '_GetVRefNum';
8972 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8973
8974
8975 { This function is deprecated in Mac OS X 10.4. Use PBXLockRangeSync or FSLockRange instead.}
8976 {
8977 * PBLockRangeSync() *** DEPRECATED ***
8978 *
8979 * Mac OS X threading:
8980 * Thread safe since version 10.0
8981 *
8982 * Availability:
8983 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
8984 * CarbonLib: in CarbonLib 1.0 and later
8985 * Non-Carbon CFM: in InterfaceLib 7.1 and later
8986 }
PBLockRangeSyncnull8987 function PBLockRangeSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBLockRangeSync';
8988 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
8989
8990
8991 { This function is deprecated in Mac OS X 10.4. Use PBXLockRangeAsync instead.}
8992 {
8993 * PBLockRangeAsync() *** DEPRECATED ***
8994 *
8995 * Mac OS X threading:
8996 * Thread safe since version 10.0
8997 *
8998 * Availability:
8999 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9000 * CarbonLib: in CarbonLib 1.0 and later
9001 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9002 }
PBLockRangeAsyncnull9003 function PBLockRangeAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBLockRangeAsync';
9004 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9005
9006
9007 { This function is deprecated in Mac OS X 10.4. Use PBXUnlockRangeSync or FSUnlockRange instead.}
9008 {
9009 * PBUnlockRangeSync() *** DEPRECATED ***
9010 *
9011 * Mac OS X threading:
9012 * Thread safe since version 10.0
9013 *
9014 * Availability:
9015 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9016 * CarbonLib: in CarbonLib 1.0 and later
9017 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9018 }
PBUnlockRangeSyncnull9019 function PBUnlockRangeSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBUnlockRangeSync';
9020 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9021
9022
9023 { This function is deprecated in Mac OS X 10.4. Use PBXUnlockRangeAsync instead.}
9024 {
9025 * PBUnlockRangeAsync() *** DEPRECATED ***
9026 *
9027 * Mac OS X threading:
9028 * Thread safe since version 10.0
9029 *
9030 * Availability:
9031 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9032 * CarbonLib: in CarbonLib 1.0 and later
9033 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9034 }
PBUnlockRangeAsyncnull9035 function PBUnlockRangeAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBUnlockRangeAsync';
9036 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9037
9038
9039 { This function is deprecated in Mac OS X 10.4. The routines which use the default volume concept have been deprecated.}
9040 {
9041 * PBHSetVolSync() *** DEPRECATED ***
9042 *
9043 * Mac OS X threading:
9044 * Thread safe since version 10.0
9045 *
9046 * Availability:
9047 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9048 * CarbonLib: in CarbonLib 1.0 and later
9049 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9050 }
PBHSetVolSyncnull9051 function PBHSetVolSync( paramBlock: WDPBPtr ): OSErr; external name '_PBHSetVolSync';
9052 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9053
9054
9055 { This function is deprecated in Mac OS X 10.4. The routines which use the default volume concept have been deprecated.}
9056 {
9057 * PBHSetVolAsync() *** DEPRECATED ***
9058 *
9059 * Mac OS X threading:
9060 * Thread safe since version 10.0
9061 *
9062 * Availability:
9063 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9064 * CarbonLib: in CarbonLib 1.0 and later
9065 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9066 }
PBHSetVolAsyncnull9067 function PBHSetVolAsync( paramBlock: WDPBPtr ): OSErr; external name '_PBHSetVolAsync';
9068 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9069
9070
9071 { This function is deprecated in Mac OS X 10.4. The routines which use the default volume concept have been deprecated.}
9072 {
9073 * PBHGetVolSync() *** DEPRECATED ***
9074 *
9075 * Mac OS X threading:
9076 * Thread safe since version 10.0
9077 *
9078 * Availability:
9079 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9080 * CarbonLib: in CarbonLib 1.0 and later
9081 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9082 }
PBHGetVolSyncnull9083 function PBHGetVolSync( paramBlock: WDPBPtr ): OSErr; external name '_PBHGetVolSync';
9084 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9085
9086
9087 { This function is deprecated in Mac OS X 10.4. The routines which use the default volume concept have been deprecated.}
9088 {
9089 * PBHGetVolAsync() *** DEPRECATED ***
9090 *
9091 * Mac OS X threading:
9092 * Thread safe since version 10.0
9093 *
9094 * Availability:
9095 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9096 * CarbonLib: in CarbonLib 1.0 and later
9097 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9098 }
PBHGetVolAsyncnull9099 function PBHGetVolAsync( paramBlock: WDPBPtr ): OSErr; external name '_PBHGetVolAsync';
9100 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9101
9102
9103 { This function is deprecated in Mac OS X 10.4. Use PBMoveObjectSync instead.}
9104 {
9105 * PBCatMoveSync() *** DEPRECATED ***
9106 *
9107 * Mac OS X threading:
9108 * Thread safe since version 10.0
9109 *
9110 * Availability:
9111 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9112 * CarbonLib: in CarbonLib 1.0 and later
9113 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9114 }
PBCatMoveSyncnull9115 function PBCatMoveSync( paramBlock: CMovePBPtr ): OSErr; external name '_PBCatMoveSync';
9116 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9117
9118
9119 { This function is deprecated in Mac OS X 10.4. Use PBMoveObjectAsync instead.}
9120 {
9121 * PBCatMoveAsync() *** DEPRECATED ***
9122 *
9123 * Mac OS X threading:
9124 * Thread safe since version 10.0
9125 *
9126 * Availability:
9127 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9128 * CarbonLib: in CarbonLib 1.0 and later
9129 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9130 }
PBCatMoveAsyncnull9131 function PBCatMoveAsync( paramBlock: CMovePBPtr ): OSErr; external name '_PBCatMoveAsync';
9132 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9133
9134
9135 { This function is deprecated in Mac OS X 10.4. Use PBCreateDirectoryUnicodeSync instead.}
9136 {
9137 * PBDirCreateSync() *** DEPRECATED ***
9138 *
9139 * Mac OS X threading:
9140 * Thread safe since version 10.0
9141 *
9142 * Availability:
9143 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9144 * CarbonLib: in CarbonLib 1.0 and later
9145 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9146 }
PBDirCreateSyncnull9147 function PBDirCreateSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBDirCreateSync';
9148 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9149
9150
9151 { This function is deprecated in Mac OS X 10.4. Use PBCreateDirectoryUnicodeAsync instead.}
9152 {
9153 * PBDirCreateAsync() *** DEPRECATED ***
9154 *
9155 * Mac OS X threading:
9156 * Thread safe since version 10.0
9157 *
9158 * Availability:
9159 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9160 * CarbonLib: in CarbonLib 1.0 and later
9161 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9162 }
PBDirCreateAsyncnull9163 function PBDirCreateAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBDirCreateAsync';
9164 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9165
9166
9167 { This function is deprecated in Mac OS X 10.4. Use PBGetForkCBInfoSync instead.}
9168 {
9169 * PBGetFCBInfoSync() *** DEPRECATED ***
9170 *
9171 * Mac OS X threading:
9172 * Thread safe since version 10.0
9173 *
9174 * Availability:
9175 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9176 * CarbonLib: in CarbonLib 1.0 and later
9177 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9178 }
PBGetFCBInfoSyncnull9179 function PBGetFCBInfoSync( paramBlock: FCBPBPtr ): OSErr; external name '_PBGetFCBInfoSync';
9180 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9181
9182
9183 { This function is deprecated in Mac OS X 10.4. Use PBGetForkCBInfoAsync instead.}
9184 {
9185 * PBGetFCBInfoAsync() *** DEPRECATED ***
9186 *
9187 * Mac OS X threading:
9188 * Thread safe since version 10.0
9189 *
9190 * Availability:
9191 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9192 * CarbonLib: in CarbonLib 1.0 and later
9193 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9194 }
PBGetFCBInfoAsyncnull9195 function PBGetFCBInfoAsync( paramBlock: FCBPBPtr ): OSErr; external name '_PBGetFCBInfoAsync';
9196 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9197
9198
9199 { This function is deprecated in Mac OS X 10.4. Use PBGetCatalogInfoSync instead.}
9200 {
9201 * PBGetCatInfoSync() *** DEPRECATED ***
9202 *
9203 * Mac OS X threading:
9204 * Thread safe since version 10.0
9205 *
9206 * Availability:
9207 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9208 * CarbonLib: in CarbonLib 1.0 and later
9209 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9210 }
PBGetCatInfoSyncnull9211 function PBGetCatInfoSync( paramBlock: CInfoPBPtr ): OSErr; external name '_PBGetCatInfoSync';
9212 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9213
9214
9215 { This function is deprecated in Mac OS X 10.4. Use PBGetCatalogInfoAsync instead.}
9216 {
9217 * PBGetCatInfoAsync() *** DEPRECATED ***
9218 *
9219 * Mac OS X threading:
9220 * Thread safe since version 10.0
9221 *
9222 * Availability:
9223 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9224 * CarbonLib: in CarbonLib 1.0 and later
9225 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9226 }
PBGetCatInfoAsyncnull9227 function PBGetCatInfoAsync( paramBlock: CInfoPBPtr ): OSErr; external name '_PBGetCatInfoAsync';
9228 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9229
9230
9231 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoSync instead.}
9232 {
9233 * PBSetCatInfoSync() *** DEPRECATED ***
9234 *
9235 * Mac OS X threading:
9236 * Thread safe since version 10.0
9237 *
9238 * Availability:
9239 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9240 * CarbonLib: in CarbonLib 1.0 and later
9241 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9242 }
PBSetCatInfoSyncnull9243 function PBSetCatInfoSync( paramBlock: CInfoPBPtr ): OSErr; external name '_PBSetCatInfoSync';
9244 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9245
9246
9247 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoAsync instead.}
9248 {
9249 * PBSetCatInfoAsync() *** DEPRECATED ***
9250 *
9251 * Mac OS X threading:
9252 * Thread safe since version 10.0
9253 *
9254 * Availability:
9255 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9256 * CarbonLib: in CarbonLib 1.0 and later
9257 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9258 }
PBSetCatInfoAsyncnull9259 function PBSetCatInfoAsync( paramBlock: CInfoPBPtr ): OSErr; external name '_PBSetCatInfoAsync';
9260 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9261
9262
9263 { This function is deprecated in Mac OS X 10.4. Use PBAllocateForkSync instead.}
9264 {
9265 * PBAllocContigSync() *** DEPRECATED ***
9266 *
9267 * Mac OS X threading:
9268 * Thread safe since version 10.0
9269 *
9270 * Availability:
9271 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9272 * CarbonLib: in CarbonLib 1.0 and later
9273 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9274 }
PBAllocContigSyncnull9275 function PBAllocContigSync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBAllocContigSync';
9276 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9277
9278
9279 { This function is deprecated in Mac OS X 10.4. Use PBAllocateForkAsync instead.}
9280 {
9281 * PBAllocContigAsync() *** DEPRECATED ***
9282 *
9283 * Mac OS X threading:
9284 * Thread safe since version 10.0
9285 *
9286 * Availability:
9287 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9288 * CarbonLib: in CarbonLib 1.0 and later
9289 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9290 }
PBAllocContigAsyncnull9291 function PBAllocContigAsync( paramBlock: ParmBlkPtr ): OSErr; external name '_PBAllocContigAsync';
9292 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9293
9294
9295 { This function is deprecated in Mac OS X 10.4. Use PBSetVolumeInfoSync instead.}
9296 {
9297 * PBSetVInfoSync() *** DEPRECATED ***
9298 *
9299 * Mac OS X threading:
9300 * Thread safe since version 10.0
9301 *
9302 * Availability:
9303 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9304 * CarbonLib: in CarbonLib 1.0 and later
9305 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9306 }
PBSetVInfoSyncnull9307 function PBSetVInfoSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBSetVInfoSync';
9308 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9309
9310
9311 { This function is deprecated in Mac OS X 10.4. Use PBSetVolumeInfoAsync instead.}
9312 {
9313 * PBSetVInfoAsync() *** DEPRECATED ***
9314 *
9315 * Mac OS X threading:
9316 * Thread safe since version 10.0
9317 *
9318 * Availability:
9319 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9320 * CarbonLib: in CarbonLib 1.0 and later
9321 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9322 }
PBSetVInfoAsyncnull9323 function PBSetVInfoAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBSetVInfoAsync';
9324 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9325
9326
9327 { This function is deprecated in Mac OS X 10.4. Use PBGetVolumeInfoSync instead.}
9328 {
9329 * PBHGetVInfoSync() *** DEPRECATED ***
9330 *
9331 * Mac OS X threading:
9332 * Thread safe since version 10.0
9333 *
9334 * Availability:
9335 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9336 * CarbonLib: in CarbonLib 1.0 and later
9337 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9338 }
PBHGetVInfoSyncnull9339 function PBHGetVInfoSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetVInfoSync';
9340 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9341
9342
9343 { This function is deprecated in Mac OS X 10.4. Use PBGetVolumeInfoAsync instead.}
9344 {
9345 * PBHGetVInfoAsync() *** DEPRECATED ***
9346 *
9347 * Mac OS X threading:
9348 * Thread safe since version 10.0
9349 *
9350 * Availability:
9351 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9352 * CarbonLib: in CarbonLib 1.0 and later
9353 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9354 }
PBHGetVInfoAsyncnull9355 function PBHGetVInfoAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetVInfoAsync';
9356 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9357
9358
9359 { This function is deprecated in Mac OS X 10.4. Use PBOpenForkSync instead.}
9360 {
9361 * PBHOpenSync() *** DEPRECATED ***
9362 *
9363 * Mac OS X threading:
9364 * Thread safe since version 10.0
9365 *
9366 * Availability:
9367 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9368 * CarbonLib: in CarbonLib 1.0 and later
9369 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9370 }
PBHOpenSyncnull9371 function PBHOpenSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenSync';
9372 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9373
9374
9375 { This function is deprecated in Mac OS X 10.4. Use PBOpenForkAsync instead.}
9376 {
9377 * PBHOpenAsync() *** DEPRECATED ***
9378 *
9379 * Mac OS X threading:
9380 * Thread safe since version 10.0
9381 *
9382 * Availability:
9383 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9384 * CarbonLib: in CarbonLib 1.0 and later
9385 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9386 }
PBHOpenAsyncnull9387 function PBHOpenAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenAsync';
9388 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9389
9390
9391 { This function is deprecated in Mac OS X 10.4. Use PBOpenForkSync instead.}
9392 {
9393 * PBHOpenRFSync() *** DEPRECATED ***
9394 *
9395 * Mac OS X threading:
9396 * Thread safe since version 10.0
9397 *
9398 * Availability:
9399 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9400 * CarbonLib: in CarbonLib 1.0 and later
9401 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9402 }
PBHOpenRFSyncnull9403 function PBHOpenRFSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenRFSync';
9404 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9405
9406
9407 { This function is deprecated in Mac OS X 10.4. Use PBOpenForkAsync instead.}
9408 {
9409 * PBHOpenRFAsync() *** DEPRECATED ***
9410 *
9411 * Mac OS X threading:
9412 * Thread safe since version 10.0
9413 *
9414 * Availability:
9415 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9416 * CarbonLib: in CarbonLib 1.0 and later
9417 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9418 }
PBHOpenRFAsyncnull9419 function PBHOpenRFAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenRFAsync';
9420 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9421
9422
9423 { This function is deprecated in Mac OS X 10.4. Use PBOpenForkSync instead.}
9424 {
9425 * PBHOpenDFSync() *** DEPRECATED ***
9426 *
9427 * Mac OS X threading:
9428 * Thread safe since version 10.0
9429 *
9430 * Availability:
9431 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9432 * CarbonLib: in CarbonLib 1.0 and later
9433 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9434 }
PBHOpenDFSyncnull9435 function PBHOpenDFSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenDFSync';
9436 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9437
9438
9439 { This function is deprecated in Mac OS X 10.4. Use PBOpenForkAsync instead.}
9440 {
9441 * PBHOpenDFAsync() *** DEPRECATED ***
9442 *
9443 * Mac OS X threading:
9444 * Thread safe since version 10.0
9445 *
9446 * Availability:
9447 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9448 * CarbonLib: in CarbonLib 1.0 and later
9449 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9450 }
PBHOpenDFAsyncnull9451 function PBHOpenDFAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHOpenDFAsync';
9452 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9453
9454
9455 { This function is deprecated in Mac OS X 10.4. Use PBCreateFileUnicodeSync instead.}
9456 {
9457 * PBHCreateSync() *** DEPRECATED ***
9458 *
9459 * Mac OS X threading:
9460 * Thread safe since version 10.0
9461 *
9462 * Availability:
9463 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9464 * CarbonLib: in CarbonLib 1.0 and later
9465 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9466 }
PBHCreateSyncnull9467 function PBHCreateSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHCreateSync';
9468 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9469
9470
9471 { This function is deprecated in Mac OS X 10.4. Use PBCreateFileUnicodeAsync instead.}
9472 {
9473 * PBHCreateAsync() *** DEPRECATED ***
9474 *
9475 * Mac OS X threading:
9476 * Thread safe since version 10.0
9477 *
9478 * Availability:
9479 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9480 * CarbonLib: in CarbonLib 1.0 and later
9481 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9482 }
PBHCreateAsyncnull9483 function PBHCreateAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHCreateAsync';
9484 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9485
9486
9487 { This function is deprecated in Mac OS X 10.4. Use PBDeleteObjectSync instead.}
9488 {
9489 * PBHDeleteSync() *** DEPRECATED ***
9490 *
9491 * Mac OS X threading:
9492 * Thread safe since version 10.0
9493 *
9494 * Availability:
9495 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9496 * CarbonLib: in CarbonLib 1.0 and later
9497 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9498 }
PBHDeleteSyncnull9499 function PBHDeleteSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHDeleteSync';
9500 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9501
9502
9503 { This function is deprecated in Mac OS X 10.4. Use PBDeleteObjectAsync instead.}
9504 {
9505 * PBHDeleteAsync() *** DEPRECATED ***
9506 *
9507 * Mac OS X threading:
9508 * Thread safe since version 10.0
9509 *
9510 * Availability:
9511 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9512 * CarbonLib: in CarbonLib 1.0 and later
9513 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9514 }
PBHDeleteAsyncnull9515 function PBHDeleteAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHDeleteAsync';
9516 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9517
9518
9519 { This function is deprecated in Mac OS X 10.4. Use PBRenameUnicodeSync instead.}
9520 {
9521 * PBHRenameSync() *** DEPRECATED ***
9522 *
9523 * Mac OS X threading:
9524 * Thread safe since version 10.0
9525 *
9526 * Availability:
9527 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9528 * CarbonLib: in CarbonLib 1.0 and later
9529 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9530 }
PBHRenameSyncnull9531 function PBHRenameSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHRenameSync';
9532 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9533
9534
9535 { This function is deprecated in Mac OS X 10.4. Use PBRenameUnicodeAsync instead.}
9536 {
9537 * PBHRenameAsync() *** DEPRECATED ***
9538 *
9539 * Mac OS X threading:
9540 * Thread safe since version 10.0
9541 *
9542 * Availability:
9543 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9544 * CarbonLib: in CarbonLib 1.0 and later
9545 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9546 }
PBHRenameAsyncnull9547 function PBHRenameAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHRenameAsync';
9548 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9549
9550
9551 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoSync instead.}
9552 {
9553 * PBHRstFLockSync() *** DEPRECATED ***
9554 *
9555 * Mac OS X threading:
9556 * Thread safe since version 10.0
9557 *
9558 * Availability:
9559 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9560 * CarbonLib: in CarbonLib 1.0 and later
9561 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9562 }
PBHRstFLockSyncnull9563 function PBHRstFLockSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHRstFLockSync';
9564 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9565
9566
9567 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoAsync instead.}
9568 {
9569 * PBHRstFLockAsync() *** DEPRECATED ***
9570 *
9571 * Mac OS X threading:
9572 * Thread safe since version 10.0
9573 *
9574 * Availability:
9575 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9576 * CarbonLib: in CarbonLib 1.0 and later
9577 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9578 }
PBHRstFLockAsyncnull9579 function PBHRstFLockAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHRstFLockAsync';
9580 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9581
9582
9583 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoSync instead.}
9584 {
9585 * PBHSetFLockSync() *** DEPRECATED ***
9586 *
9587 * Mac OS X threading:
9588 * Thread safe since version 10.0
9589 *
9590 * Availability:
9591 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9592 * CarbonLib: in CarbonLib 1.0 and later
9593 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9594 }
PBHSetFLockSyncnull9595 function PBHSetFLockSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHSetFLockSync';
9596 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9597
9598
9599 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoAsync instead.}
9600 {
9601 * PBHSetFLockAsync() *** DEPRECATED ***
9602 *
9603 * Mac OS X threading:
9604 * Thread safe since version 10.0
9605 *
9606 * Availability:
9607 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9608 * CarbonLib: in CarbonLib 1.0 and later
9609 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9610 }
PBHSetFLockAsyncnull9611 function PBHSetFLockAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHSetFLockAsync';
9612 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9613
9614
9615 { This function is deprecated in Mac OS X 10.4. Use PBGetCatalogInfoSync instead.}
9616 {
9617 * PBHGetFInfoSync() *** DEPRECATED ***
9618 *
9619 * Mac OS X threading:
9620 * Thread safe since version 10.0
9621 *
9622 * Availability:
9623 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9624 * CarbonLib: in CarbonLib 1.0 and later
9625 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9626 }
PBHGetFInfoSyncnull9627 function PBHGetFInfoSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetFInfoSync';
9628 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9629
9630
9631 { This function is deprecated in Mac OS X 10.4. Use PBGetCatalogInfoAsync instead.}
9632 {
9633 * PBHGetFInfoAsync() *** DEPRECATED ***
9634 *
9635 * Mac OS X threading:
9636 * Thread safe since version 10.0
9637 *
9638 * Availability:
9639 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9640 * CarbonLib: in CarbonLib 1.0 and later
9641 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9642 }
PBHGetFInfoAsyncnull9643 function PBHGetFInfoAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetFInfoAsync';
9644 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9645
9646
9647 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoSync instead.}
9648 {
9649 * PBHSetFInfoSync() *** DEPRECATED ***
9650 *
9651 * Mac OS X threading:
9652 * Thread safe since version 10.0
9653 *
9654 * Availability:
9655 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9656 * CarbonLib: in CarbonLib 1.0 and later
9657 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9658 }
PBHSetFInfoSyncnull9659 function PBHSetFInfoSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHSetFInfoSync';
9660 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9661
9662
9663 { This function is deprecated in Mac OS X 10.4. Use PBSetCatalogInfoAsync instead.}
9664 {
9665 * PBHSetFInfoAsync() *** DEPRECATED ***
9666 *
9667 * Mac OS X threading:
9668 * Thread safe since version 10.0
9669 *
9670 * Availability:
9671 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9672 * CarbonLib: in CarbonLib 1.0 and later
9673 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9674 }
PBHSetFInfoAsyncnull9675 function PBHSetFInfoAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHSetFInfoAsync';
9676 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9677
9678
9679 { This function is deprecated in Mac OS X 10.4. Use PBMakeFSRefUnicodeSync instead.}
9680 {
9681 * PBMakeFSSpecSync() *** DEPRECATED ***
9682 *
9683 * Mac OS X threading:
9684 * Thread safe since version 10.0
9685 *
9686 * Availability:
9687 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9688 * CarbonLib: in CarbonLib 1.0 and later
9689 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9690 }
PBMakeFSSpecSyncnull9691 function PBMakeFSSpecSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBMakeFSSpecSync';
9692 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9693
9694
9695 { This function is deprecated in Mac OS X 10.4. Use PBMakeFSRefUnicodeAsync instead.}
9696 {
9697 * PBMakeFSSpecAsync() *** DEPRECATED ***
9698 *
9699 * Mac OS X threading:
9700 * Thread safe since version 10.0
9701 *
9702 * Availability:
9703 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9704 * CarbonLib: in CarbonLib 1.0 and later
9705 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9706 }
PBMakeFSSpecAsyncnull9707 function PBMakeFSSpecAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBMakeFSSpecAsync';
9708 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9709
9710
9711 { This function is deprecated in Mac OS X 10.4. The routines which use the default volume concept have been deprecated.}
9712 {
9713 * HGetVol() *** DEPRECATED ***
9714 *
9715 * Mac OS X threading:
9716 * Thread safe since version 10.0
9717 *
9718 * Availability:
9719 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9720 * CarbonLib: in CarbonLib 1.0 and later
9721 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9722 }
HGetVolnull9723 function HGetVol( volName: StringPtr; var vRefNum: FSVolumeRefNum; var dirID: SInt32 ): OSErr; external name '_HGetVol';
9724 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9725
9726
9727 { This function is deprecated in Mac OS X 10.4. Use FSOpenFork instead.}
9728 {
9729 * HOpen() *** DEPRECATED ***
9730 *
9731 * Mac OS X threading:
9732 * Thread safe since version 10.0
9733 *
9734 * Availability:
9735 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9736 * CarbonLib: in CarbonLib 1.0 and later
9737 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9738 }
HOpennull9739 function HOpen( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; permission: SInt8; var refNum: FSIORefNum ): OSErr; external name '_HOpen';
9740 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9741
9742
9743 { This function is deprecated in Mac OS X 10.4. Use FSOpenFork instead.}
9744 {
9745 * HOpenDF() *** DEPRECATED ***
9746 *
9747 * Mac OS X threading:
9748 * Thread safe since version 10.0
9749 *
9750 * Availability:
9751 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9752 * CarbonLib: in CarbonLib 1.0 and later
9753 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9754 }
HOpenDFnull9755 function HOpenDF( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; permission: SInt8; var refNum: FSIORefNum ): OSErr; external name '_HOpenDF';
9756 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9757
9758
9759 { This function is deprecated in Mac OS X 10.4. Use FSOpenFork instead.}
9760 {
9761 * HOpenRF() *** DEPRECATED ***
9762 *
9763 * Mac OS X threading:
9764 * Thread safe since version 10.0
9765 *
9766 * Availability:
9767 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9768 * CarbonLib: in CarbonLib 1.0 and later
9769 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9770 }
HOpenRFnull9771 function HOpenRF( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; permission: SInt8; var refNum: FSIORefNum ): OSErr; external name '_HOpenRF';
9772 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9773
9774
9775 { This function is deprecated in Mac OS X 10.4. Use FSAllocateFork instead.}
9776 {
9777 * AllocContig() *** DEPRECATED ***
9778 *
9779 * Mac OS X threading:
9780 * Thread safe since version 10.0
9781 *
9782 * Availability:
9783 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9784 * CarbonLib: in CarbonLib 1.0 and later
9785 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9786 }
AllocContignull9787 function AllocContig( refNum: FSVolumeRefNum; var count: SInt32 ): OSErr; external name '_AllocContig';
9788 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9789
9790
9791 { This function is deprecated in Mac OS X 10.4. Use FSCreateFileUnicode instead.}
9792 {
9793 * HCreate() *** DEPRECATED ***
9794 *
9795 * Mac OS X threading:
9796 * Thread safe since version 10.0
9797 *
9798 * Availability:
9799 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9800 * CarbonLib: in CarbonLib 1.0 and later
9801 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9802 }
HCreatenull9803 function HCreate( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; creator: OSType; fileType: OSType ): OSErr; external name '_HCreate';
9804 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9805
9806
9807 { This function is deprecated in Mac OS X 10.4. Use FSCreateDirectoryUnicode instead.}
9808 {
9809 * DirCreate() *** DEPRECATED ***
9810 *
9811 * Mac OS X threading:
9812 * Thread safe since version 10.0
9813 *
9814 * Availability:
9815 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9816 * CarbonLib: in CarbonLib 1.0 and later
9817 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9818 }
DirCreatenull9819 function DirCreate( vRefNum: FSVolumeRefNum; parentDirID: SInt32; const (*var*) directoryName: Str255; var createdDirID: SInt32 ): OSErr; external name '_DirCreate';
9820 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9821
9822
9823 { This function is deprecated in Mac OS X 10.4. Use FSDeleteObject instead.}
9824 {
9825 * HDelete() *** DEPRECATED ***
9826 *
9827 * Mac OS X threading:
9828 * Thread safe since version 10.0
9829 *
9830 * Availability:
9831 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9832 * CarbonLib: in CarbonLib 1.0 and later
9833 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9834 }
HDeletenull9835 function HDelete( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255 ): OSErr; external name '_HDelete';
9836 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9837
9838
9839 { This function is deprecated in Mac OS X 10.4. Use FSGetCatalogInfo instead.}
9840 {
9841 * HGetFInfo() *** DEPRECATED ***
9842 *
9843 * Mac OS X threading:
9844 * Thread safe since version 10.0
9845 *
9846 * Availability:
9847 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9848 * CarbonLib: in CarbonLib 1.0 and later
9849 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9850 }
HGetFInfonull9851 function HGetFInfo( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; var fndrInfo: FInfo ): OSErr; external name '_HGetFInfo';
9852 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9853
9854
9855 { This function is deprecated in Mac OS X 10.4. Use FSSetCatalogInfo instead.}
9856 {
9857 * HSetFInfo() *** DEPRECATED ***
9858 *
9859 * Mac OS X threading:
9860 * Thread safe since version 10.0
9861 *
9862 * Availability:
9863 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9864 * CarbonLib: in CarbonLib 1.0 and later
9865 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9866 }
HSetFInfonull9867 function HSetFInfo( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; const (*var*) fndrInfo: FInfo ): OSErr; external name '_HSetFInfo';
9868 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9869
9870
9871 { This function is deprecated in Mac OS X 10.4. Use FSSetCatalogInfo instead.}
9872 {
9873 * HSetFLock() *** DEPRECATED ***
9874 *
9875 * Mac OS X threading:
9876 * Thread safe since version 10.0
9877 *
9878 * Availability:
9879 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9880 * CarbonLib: in CarbonLib 1.0 and later
9881 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9882 }
HSetFLocknull9883 function HSetFLock( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255 ): OSErr; external name '_HSetFLock';
9884 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9885
9886
9887 { This function is deprecated in Mac OS X 10.4. Use FSSetCatalogInfo instead.}
9888 {
9889 * HRstFLock() *** DEPRECATED ***
9890 *
9891 * Mac OS X threading:
9892 * Thread safe since version 10.0
9893 *
9894 * Availability:
9895 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9896 * CarbonLib: in CarbonLib 1.0 and later
9897 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9898 }
HRstFLocknull9899 function HRstFLock( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255 ): OSErr; external name '_HRstFLock';
9900 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9901
9902
9903 { This function is deprecated in Mac OS X 10.4. Use FSRenameUnicode instead.}
9904 {
9905 * HRename() *** DEPRECATED ***
9906 *
9907 * Mac OS X threading:
9908 * Thread safe since version 10.0
9909 *
9910 * Availability:
9911 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9912 * CarbonLib: in CarbonLib 1.0 and later
9913 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9914 }
HRenamenull9915 function HRename( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) oldName: Str255; const (*var*) newName: Str255 ): OSErr; external name '_HRename';
9916 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9917
9918
9919 { This function is deprecated in Mac OS X 10.4. Use FSMoveObject instead.}
9920 {
9921 * CatMove() *** DEPRECATED ***
9922 *
9923 * Mac OS X threading:
9924 * Thread safe since version 10.0
9925 *
9926 * Availability:
9927 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9928 * CarbonLib: in CarbonLib 1.0 and later
9929 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9930 }
CatMovenull9931 function CatMove( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) oldName: Str255; newDirID: SInt32; const (*var*) newName: Str255 ): OSErr; external name '_CatMove';
9932 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9933
9934
9935 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
9936 {
9937 * PBHGetLogInInfoSync() *** DEPRECATED ***
9938 *
9939 * Mac OS X threading:
9940 * Thread safe since version 10.0
9941 *
9942 * Availability:
9943 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9944 * CarbonLib: in CarbonLib 1.0 and later
9945 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9946 }
PBHGetLogInInfoSyncnull9947 function PBHGetLogInInfoSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetLogInInfoSync';
9948 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9949
9950
9951 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
9952 {
9953 * PBHGetLogInInfoAsync() *** DEPRECATED ***
9954 *
9955 * Mac OS X threading:
9956 * Thread safe since version 10.0
9957 *
9958 * Availability:
9959 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9960 * CarbonLib: in CarbonLib 1.0 and later
9961 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9962 }
PBHGetLogInInfoAsyncnull9963 function PBHGetLogInInfoAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHGetLogInInfoAsync';
9964 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9965
9966
9967 {
9968 This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.
9969 Use FSMoveObjectSync instead.
9970 }
9971 {
9972 * PBHMoveRenameSync() *** DEPRECATED ***
9973 *
9974 * Mac OS X threading:
9975 * Thread safe since version 10.0
9976 *
9977 * Availability:
9978 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9979 * CarbonLib: in CarbonLib 1.0 and later
9980 * Non-Carbon CFM: in InterfaceLib 7.1 and later
9981 }
PBHMoveRenameSyncnull9982 function PBHMoveRenameSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHMoveRenameSync';
9983 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
9984
9985
9986 {
9987 This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.
9988 Use FSMoveObjectAsync instead.
9989 }
9990 {
9991 * PBHMoveRenameAsync() *** DEPRECATED ***
9992 *
9993 * Mac OS X threading:
9994 * Thread safe since version 10.0
9995 *
9996 * Availability:
9997 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
9998 * CarbonLib: in CarbonLib 1.0 and later
9999 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10000 }
PBHMoveRenameAsyncnull10001 function PBHMoveRenameAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBHMoveRenameAsync';
10002 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10003
10004
10005 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10006 {
10007 * PBGetXCatInfoSync() *** DEPRECATED ***
10008 *
10009 * Mac OS X threading:
10010 * Thread safe since version 10.0
10011 *
10012 * Availability:
10013 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10014 * CarbonLib: in CarbonLib 1.0 and later
10015 * Non-Carbon CFM: in InterfaceLib 8.5 and later
10016 }
PBGetXCatInfoSyncnull10017 function PBGetXCatInfoSync( paramBlock: XCInfoPBPtr ): OSErr; external name '_PBGetXCatInfoSync';
10018 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10019
10020
10021 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10022 {
10023 * PBGetXCatInfoAsync() *** DEPRECATED ***
10024 *
10025 * Mac OS X threading:
10026 * Thread safe since version 10.0
10027 *
10028 * Availability:
10029 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10030 * CarbonLib: in CarbonLib 1.0 and later
10031 * Non-Carbon CFM: in InterfaceLib 8.5 and later
10032 }
PBGetXCatInfoAsyncnull10033 function PBGetXCatInfoAsync( paramBlock: XCInfoPBPtr ): OSErr; external name '_PBGetXCatInfoAsync';
10034 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10035
10036
10037 { This function is deprecated in Mac OS X 10.4. Use PBExchangeObjectsSync instead.}
10038 {
10039 * PBExchangeFilesSync() *** DEPRECATED ***
10040 *
10041 * Mac OS X threading:
10042 * Thread safe since version 10.0
10043 *
10044 * Availability:
10045 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10046 * CarbonLib: in CarbonLib 1.0 and later
10047 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10048 }
PBExchangeFilesSyncnull10049 function PBExchangeFilesSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBExchangeFilesSync';
10050 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10051
10052
10053 { This function is deprecated in Mac OS X 10.4. Use PBExchangeObjectsAsync instead.}
10054 {
10055 * PBExchangeFilesAsync() *** DEPRECATED ***
10056 *
10057 * Mac OS X threading:
10058 * Thread safe since version 10.0
10059 *
10060 * Availability:
10061 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10062 * CarbonLib: in CarbonLib 1.0 and later
10063 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10064 }
PBExchangeFilesAsyncnull10065 function PBExchangeFilesAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBExchangeFilesAsync';
10066 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10067
10068
10069 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10070 {
10071 * PBGetForeignPrivsSync() *** DEPRECATED ***
10072 *
10073 * Mac OS X threading:
10074 * Thread safe since version 10.0
10075 *
10076 * Availability:
10077 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10078 * CarbonLib: in CarbonLib 1.0 and later
10079 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10080 }
PBGetForeignPrivsSyncnull10081 function PBGetForeignPrivsSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBGetForeignPrivsSync';
10082 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10083
10084
10085 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10086 {
10087 * PBGetForeignPrivsAsync() *** DEPRECATED ***
10088 *
10089 * Mac OS X threading:
10090 * Thread safe since version 10.0
10091 *
10092 * Availability:
10093 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10094 * CarbonLib: in CarbonLib 1.0 and later
10095 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10096 }
PBGetForeignPrivsAsyncnull10097 function PBGetForeignPrivsAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBGetForeignPrivsAsync';
10098 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10099
10100
10101 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10102 {
10103 * PBSetForeignPrivsSync() *** DEPRECATED ***
10104 *
10105 * Mac OS X threading:
10106 * Thread safe since version 10.0
10107 *
10108 * Availability:
10109 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10110 * CarbonLib: in CarbonLib 1.0 and later
10111 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10112 }
PBSetForeignPrivsSyncnull10113 function PBSetForeignPrivsSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBSetForeignPrivsSync';
10114 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10115
10116
10117 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10118 {
10119 * PBSetForeignPrivsAsync() *** DEPRECATED ***
10120 *
10121 * Mac OS X threading:
10122 * Thread safe since version 10.0
10123 *
10124 * Availability:
10125 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10126 * CarbonLib: in CarbonLib 1.0 and later
10127 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10128 }
PBSetForeignPrivsAsyncnull10129 function PBSetForeignPrivsAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBSetForeignPrivsAsync';
10130 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10131
10132
10133 { Desktop Manager }
10134 {$endc} {not TARGET_CPU_64}
10135
10136 {$ifc not TARGET_CPU_64}
10137 const
10138 { Desktop Database, ffsGetIconMessage and fsmGetFSIconMessage icon type and size Constants }
10139 kLargeIcon = 1;
10140 kLarge4BitIcon = 2;
10141 kLarge8BitIcon = 3;
10142 kSmallIcon = 4;
10143 kSmall4BitIcon = 5;
10144 kSmall8BitIcon = 6;
10145 kicnsIconFamily = 239; { Note: The 'icns' icon family record is variable sized. }
10146
10147 {$endc} {not TARGET_CPU_64}
10148
10149 {$ifc not TARGET_CPU_64}
10150 {
10151 * PBDTGetPath() *** DEPRECATED ***
10152 *
10153 * Mac OS X threading:
10154 * Thread safe since version 10.2
10155 *
10156 * Availability:
10157 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10158 * CarbonLib: in CarbonLib 1.0 and later
10159 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10160 }
PBDTGetPathnull10161 function PBDTGetPath( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetPath';
10162 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10163
10164
10165 {
10166 * PBDTCloseDown() *** DEPRECATED ***
10167 *
10168 * Mac OS X threading:
10169 * Thread safe since version 10.2
10170 *
10171 * Availability:
10172 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10173 * CarbonLib: in CarbonLib 1.0 and later
10174 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10175 }
PBDTCloseDownnull10176 function PBDTCloseDown( paramBlock: DTPBPtr ): OSErr; external name '_PBDTCloseDown';
10177 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10178
10179
10180 {
10181 * PBDTAddIconSync() *** DEPRECATED ***
10182 *
10183 * Mac OS X threading:
10184 * Thread safe since version 10.2
10185 *
10186 * Availability:
10187 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10188 * CarbonLib: in CarbonLib 1.0 and later
10189 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10190 }
PBDTAddIconSyncnull10191 function PBDTAddIconSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTAddIconSync';
10192 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10193
10194
10195 {
10196 * PBDTAddIconAsync() *** DEPRECATED ***
10197 *
10198 * Mac OS X threading:
10199 * Thread safe since version 10.2
10200 *
10201 * Availability:
10202 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10203 * CarbonLib: in CarbonLib 1.0 and later
10204 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10205 }
PBDTAddIconAsyncnull10206 function PBDTAddIconAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTAddIconAsync';
10207 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10208
10209
10210 {
10211 * PBDTGetIconSync() *** DEPRECATED ***
10212 *
10213 * Mac OS X threading:
10214 * Thread safe since version 10.2
10215 *
10216 * Availability:
10217 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10218 * CarbonLib: in CarbonLib 1.0 and later
10219 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10220 }
PBDTGetIconSyncnull10221 function PBDTGetIconSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetIconSync';
10222 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10223
10224
10225 {
10226 * PBDTGetIconAsync() *** DEPRECATED ***
10227 *
10228 * Mac OS X threading:
10229 * Thread safe since version 10.2
10230 *
10231 * Availability:
10232 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10233 * CarbonLib: in CarbonLib 1.0 and later
10234 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10235 }
PBDTGetIconAsyncnull10236 function PBDTGetIconAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetIconAsync';
10237 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10238
10239
10240 {
10241 * PBDTGetIconInfoSync() *** DEPRECATED ***
10242 *
10243 * Mac OS X threading:
10244 * Thread safe since version 10.2
10245 *
10246 * Availability:
10247 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10248 * CarbonLib: in CarbonLib 1.0 and later
10249 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10250 }
PBDTGetIconInfoSyncnull10251 function PBDTGetIconInfoSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetIconInfoSync';
10252 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10253
10254
10255 {
10256 * PBDTGetIconInfoAsync() *** DEPRECATED ***
10257 *
10258 * Mac OS X threading:
10259 * Thread safe since version 10.2
10260 *
10261 * Availability:
10262 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10263 * CarbonLib: in CarbonLib 1.0 and later
10264 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10265 }
PBDTGetIconInfoAsyncnull10266 function PBDTGetIconInfoAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetIconInfoAsync';
10267 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10268
10269
10270 {
10271 * PBDTAddAPPLSync() *** DEPRECATED ***
10272 *
10273 * Mac OS X threading:
10274 * Thread safe since version 10.2
10275 *
10276 * Availability:
10277 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10278 * CarbonLib: in CarbonLib 1.0 and later
10279 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10280 }
PBDTAddAPPLSyncnull10281 function PBDTAddAPPLSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTAddAPPLSync';
10282 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10283
10284
10285 {
10286 * PBDTAddAPPLAsync() *** DEPRECATED ***
10287 *
10288 * Mac OS X threading:
10289 * Thread safe since version 10.2
10290 *
10291 * Availability:
10292 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10293 * CarbonLib: in CarbonLib 1.0 and later
10294 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10295 }
PBDTAddAPPLAsyncnull10296 function PBDTAddAPPLAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTAddAPPLAsync';
10297 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10298
10299
10300 {
10301 * PBDTRemoveAPPLSync() *** DEPRECATED ***
10302 *
10303 * Mac OS X threading:
10304 * Thread safe since version 10.2
10305 *
10306 * Availability:
10307 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10308 * CarbonLib: in CarbonLib 1.0 and later
10309 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10310 }
PBDTRemoveAPPLSyncnull10311 function PBDTRemoveAPPLSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTRemoveAPPLSync';
10312 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10313
10314
10315 {
10316 * PBDTRemoveAPPLAsync() *** DEPRECATED ***
10317 *
10318 * Mac OS X threading:
10319 * Thread safe since version 10.2
10320 *
10321 * Availability:
10322 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10323 * CarbonLib: in CarbonLib 1.0 and later
10324 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10325 }
PBDTRemoveAPPLAsyncnull10326 function PBDTRemoveAPPLAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTRemoveAPPLAsync';
10327 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10328
10329
10330 {
10331 * PBDTGetAPPLSync() *** DEPRECATED ***
10332 *
10333 * Mac OS X threading:
10334 * Thread safe since version 10.2
10335 *
10336 * Availability:
10337 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10338 * CarbonLib: in CarbonLib 1.0 and later
10339 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10340 }
PBDTGetAPPLSyncnull10341 function PBDTGetAPPLSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetAPPLSync';
10342 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10343
10344
10345 {
10346 * PBDTGetAPPLAsync() *** DEPRECATED ***
10347 *
10348 * Mac OS X threading:
10349 * Thread safe since version 10.2
10350 *
10351 * Availability:
10352 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10353 * CarbonLib: in CarbonLib 1.0 and later
10354 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10355 }
PBDTGetAPPLAsyncnull10356 function PBDTGetAPPLAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetAPPLAsync';
10357 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10358
10359
10360 {
10361 * PBDTSetCommentSync() *** DEPRECATED ***
10362 *
10363 * Mac OS X threading:
10364 * Thread safe since version 10.2
10365 *
10366 * Availability:
10367 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10368 * CarbonLib: in CarbonLib 1.0 and later
10369 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10370 }
PBDTSetCommentSyncnull10371 function PBDTSetCommentSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTSetCommentSync';
10372 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10373
10374
10375 {
10376 * PBDTSetCommentAsync() *** DEPRECATED ***
10377 *
10378 * Mac OS X threading:
10379 * Thread safe since version 10.2
10380 *
10381 * Availability:
10382 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10383 * CarbonLib: in CarbonLib 1.0 and later
10384 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10385 }
PBDTSetCommentAsyncnull10386 function PBDTSetCommentAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTSetCommentAsync';
10387 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10388
10389
10390 {
10391 * PBDTRemoveCommentSync() *** DEPRECATED ***
10392 *
10393 * Mac OS X threading:
10394 * Thread safe since version 10.2
10395 *
10396 * Availability:
10397 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10398 * CarbonLib: in CarbonLib 1.0 and later
10399 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10400 }
PBDTRemoveCommentSyncnull10401 function PBDTRemoveCommentSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTRemoveCommentSync';
10402 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10403
10404
10405 {
10406 * PBDTRemoveCommentAsync() *** DEPRECATED ***
10407 *
10408 * Mac OS X threading:
10409 * Thread safe since version 10.2
10410 *
10411 * Availability:
10412 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10413 * CarbonLib: in CarbonLib 1.0 and later
10414 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10415 }
PBDTRemoveCommentAsyncnull10416 function PBDTRemoveCommentAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTRemoveCommentAsync';
10417 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10418
10419
10420 {
10421 * PBDTGetCommentSync() *** DEPRECATED ***
10422 *
10423 * Mac OS X threading:
10424 * Thread safe since version 10.2
10425 *
10426 * Availability:
10427 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10428 * CarbonLib: in CarbonLib 1.0 and later
10429 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10430 }
PBDTGetCommentSyncnull10431 function PBDTGetCommentSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetCommentSync';
10432 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10433
10434
10435 {
10436 * PBDTGetCommentAsync() *** DEPRECATED ***
10437 *
10438 * Mac OS X threading:
10439 * Thread safe since version 10.2
10440 *
10441 * Availability:
10442 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10443 * CarbonLib: in CarbonLib 1.0 and later
10444 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10445 }
PBDTGetCommentAsyncnull10446 function PBDTGetCommentAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetCommentAsync';
10447 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10448
10449
10450 {
10451 * PBDTFlushSync() *** DEPRECATED ***
10452 *
10453 * Mac OS X threading:
10454 * Thread safe since version 10.2
10455 *
10456 * Availability:
10457 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10458 * CarbonLib: in CarbonLib 1.0 and later
10459 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10460 }
PBDTFlushSyncnull10461 function PBDTFlushSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTFlushSync';
10462 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10463
10464
10465 {
10466 * PBDTFlushAsync() *** DEPRECATED ***
10467 *
10468 * Mac OS X threading:
10469 * Thread safe since version 10.2
10470 *
10471 * Availability:
10472 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10473 * CarbonLib: in CarbonLib 1.0 and later
10474 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10475 }
PBDTFlushAsyncnull10476 function PBDTFlushAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTFlushAsync';
10477 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10478
10479
10480 {
10481 * PBDTResetSync() *** DEPRECATED ***
10482 *
10483 * Mac OS X threading:
10484 * Thread safe since version 10.2
10485 *
10486 * Availability:
10487 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10488 * CarbonLib: in CarbonLib 1.0 and later
10489 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10490 }
PBDTResetSyncnull10491 function PBDTResetSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTResetSync';
10492 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10493
10494
10495 {
10496 * PBDTResetAsync() *** DEPRECATED ***
10497 *
10498 * Mac OS X threading:
10499 * Thread safe since version 10.2
10500 *
10501 * Availability:
10502 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10503 * CarbonLib: in CarbonLib 1.0 and later
10504 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10505 }
PBDTResetAsyncnull10506 function PBDTResetAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTResetAsync';
10507 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10508
10509
10510 {
10511 * PBDTGetInfoSync() *** DEPRECATED ***
10512 *
10513 * Mac OS X threading:
10514 * Thread safe since version 10.2
10515 *
10516 * Availability:
10517 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10518 * CarbonLib: in CarbonLib 1.0 and later
10519 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10520 }
PBDTGetInfoSyncnull10521 function PBDTGetInfoSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetInfoSync';
10522 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10523
10524
10525 {
10526 * PBDTGetInfoAsync() *** DEPRECATED ***
10527 *
10528 * Mac OS X threading:
10529 * Thread safe since version 10.2
10530 *
10531 * Availability:
10532 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10533 * CarbonLib: in CarbonLib 1.0 and later
10534 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10535 }
PBDTGetInfoAsyncnull10536 function PBDTGetInfoAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTGetInfoAsync';
10537 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10538
10539
10540 {
10541 * PBDTOpenInform() *** DEPRECATED ***
10542 *
10543 * Mac OS X threading:
10544 * Thread safe since version 10.2
10545 *
10546 * Availability:
10547 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10548 * CarbonLib: in CarbonLib 1.0 and later
10549 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10550 }
PBDTOpenInformnull10551 function PBDTOpenInform( paramBlock: DTPBPtr ): OSErr; external name '_PBDTOpenInform';
10552 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10553
10554
10555 {
10556 * PBDTDeleteSync() *** DEPRECATED ***
10557 *
10558 * Mac OS X threading:
10559 * Thread safe since version 10.2
10560 *
10561 * Availability:
10562 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10563 * CarbonLib: in CarbonLib 1.0 and later
10564 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10565 }
PBDTDeleteSyncnull10566 function PBDTDeleteSync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTDeleteSync';
10567 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10568
10569
10570 {
10571 * PBDTDeleteAsync() *** DEPRECATED ***
10572 *
10573 * Mac OS X threading:
10574 * Thread safe since version 10.2
10575 *
10576 * Availability:
10577 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10578 * CarbonLib: in CarbonLib 1.0 and later
10579 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10580 }
PBDTDeleteAsyncnull10581 function PBDTDeleteAsync( paramBlock: DTPBPtr ): OSErr; external name '_PBDTDeleteAsync';
10582 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10583
10584
10585 { FSp traps }
10586 { This function is deprecated in Mac OS X 10.4. Use FSMakeFSRefUnicode instead.}
10587 {
10588 * FSMakeFSSpec() *** DEPRECATED ***
10589 *
10590 * Mac OS X threading:
10591 * Thread safe since version 10.0
10592 *
10593 * Availability:
10594 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10595 * CarbonLib: in CarbonLib 1.0 and later
10596 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10597 }
FSMakeFSSpecnull10598 function FSMakeFSSpec( vRefNum: FSVolumeRefNum; dirID: SInt32; const (*var*) fileName: Str255; var spec: FSSpec ): OSErr; external name '_FSMakeFSSpec';
10599 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10600
10601
10602 { This function is deprecated in Mac OS X 10.4. Use FSOpenFork instead.}
10603 {
10604 * FSpOpenDF() *** DEPRECATED ***
10605 *
10606 * Mac OS X threading:
10607 * Thread safe since version 10.0
10608 *
10609 * Availability:
10610 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10611 * CarbonLib: in CarbonLib 1.0 and later
10612 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10613 }
FSpOpenDFnull10614 function FSpOpenDF( const (*var*) spec: FSSpec; permission: SInt8; var refNum: FSIORefNum ): OSErr; external name '_FSpOpenDF';
10615 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10616
10617
10618 { This function is deprecated in Mac OS X 10.4. Use FSOpenFork instead.}
10619 {
10620 * FSpOpenRF() *** DEPRECATED ***
10621 *
10622 * Mac OS X threading:
10623 * Thread safe since version 10.0
10624 *
10625 * Availability:
10626 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10627 * CarbonLib: in CarbonLib 1.0 and later
10628 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10629 }
FSpOpenRFnull10630 function FSpOpenRF( const (*var*) spec: FSSpec; permission: SInt8; var refNum: FSIORefNum ): OSErr; external name '_FSpOpenRF';
10631 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10632
10633
10634 { This function is deprecated in Mac OS X 10.4. Use FSCreateFileUnicode instead.}
10635 {
10636 * FSpCreate() *** DEPRECATED ***
10637 *
10638 * Mac OS X threading:
10639 * Thread safe since version 10.0
10640 *
10641 * Availability:
10642 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10643 * CarbonLib: in CarbonLib 1.0 and later
10644 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10645 }
FSpCreatenull10646 function FSpCreate( const (*var*) spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode ): OSErr; external name '_FSpCreate';
10647 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10648
10649
10650 { This function is deprecated in Mac OS X 10.4. Use FSCreateDirectoryUnicode instead.}
10651 {
10652 * FSpDirCreate() *** DEPRECATED ***
10653 *
10654 * Mac OS X threading:
10655 * Thread safe since version 10.0
10656 *
10657 * Availability:
10658 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10659 * CarbonLib: in CarbonLib 1.0 and later
10660 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10661 }
FSpDirCreatenull10662 function FSpDirCreate( const (*var*) spec: FSSpec; scriptTag: ScriptCode; var createdDirID: SInt32 ): OSErr; external name '_FSpDirCreate';
10663 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10664
10665
10666 { This function is deprecated in Mac OS X 10.4. Use FSDeleteObject instead.}
10667 {
10668 * FSpDelete() *** DEPRECATED ***
10669 *
10670 * Mac OS X threading:
10671 * Thread safe since version 10.0
10672 *
10673 * Availability:
10674 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10675 * CarbonLib: in CarbonLib 1.0 and later
10676 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10677 }
FSpDeletenull10678 function FSpDelete( const (*var*) spec: FSSpec ): OSErr; external name '_FSpDelete';
10679 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10680
10681
10682 { This function is deprecated in Mac OS X 10.4. Use FSGetCatalogInfo instead.}
10683 {
10684 * FSpGetFInfo() *** DEPRECATED ***
10685 *
10686 * Mac OS X threading:
10687 * Thread safe since version 10.0
10688 *
10689 * Availability:
10690 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10691 * CarbonLib: in CarbonLib 1.0 and later
10692 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10693 }
FSpGetFInfonull10694 function FSpGetFInfo( const (*var*) spec: FSSpec; var fndrInfo: FInfo ): OSErr; external name '_FSpGetFInfo';
10695 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10696
10697
10698 { This function is deprecated in Mac OS X 10.4. Use FSSetCatalogInfo instead.}
10699 {
10700 * FSpSetFInfo() *** DEPRECATED ***
10701 *
10702 * Mac OS X threading:
10703 * Thread safe since version 10.0
10704 *
10705 * Availability:
10706 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10707 * CarbonLib: in CarbonLib 1.0 and later
10708 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10709 }
FSpSetFInfonull10710 function FSpSetFInfo( const (*var*) spec: FSSpec; const (*var*) fndrInfo: FInfo ): OSErr; external name '_FSpSetFInfo';
10711 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10712
10713
10714 { This function is deprecated in Mac OS X 10.4. Use FSSetCatalogInfo instead.}
10715 {
10716 * FSpSetFLock() *** DEPRECATED ***
10717 *
10718 * Mac OS X threading:
10719 * Thread safe since version 10.0
10720 *
10721 * Availability:
10722 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10723 * CarbonLib: in CarbonLib 1.0 and later
10724 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10725 }
FSpSetFLocknull10726 function FSpSetFLock( const (*var*) spec: FSSpec ): OSErr; external name '_FSpSetFLock';
10727 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10728
10729
10730 { This function is deprecated in Mac OS X 10.4. Use FSSetCatalogInfo instead.}
10731 {
10732 * FSpRstFLock() *** DEPRECATED ***
10733 *
10734 * Mac OS X threading:
10735 * Thread safe since version 10.0
10736 *
10737 * Availability:
10738 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10739 * CarbonLib: in CarbonLib 1.0 and later
10740 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10741 }
FSpRstFLocknull10742 function FSpRstFLock( const (*var*) spec: FSSpec ): OSErr; external name '_FSpRstFLock';
10743 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10744
10745
10746 { This function is deprecated in Mac OS X 10.4. Use FSRenameUnicode instead.}
10747 {
10748 * FSpRename() *** DEPRECATED ***
10749 *
10750 * Mac OS X threading:
10751 * Thread safe since version 10.0
10752 *
10753 * Availability:
10754 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10755 * CarbonLib: in CarbonLib 1.0 and later
10756 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10757 }
FSpRenamenull10758 function FSpRename( const (*var*) spec: FSSpec; const (*var*) newName: Str255 ): OSErr; external name '_FSpRename';
10759 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10760
10761
10762 { This function is deprecated in Mac OS X 10.4. Use FSMoveObject instead.}
10763 {
10764 * FSpCatMove() *** DEPRECATED ***
10765 *
10766 * Mac OS X threading:
10767 * Thread safe since version 10.0
10768 *
10769 * Availability:
10770 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10771 * CarbonLib: in CarbonLib 1.0 and later
10772 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10773 }
FSpCatMovenull10774 function FSpCatMove( const (*var*) source: FSSpec; const (*var*) dest: FSSpec ): OSErr; external name '_FSpCatMove';
10775 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10776
10777
10778 { This function is deprecated in Mac OS X 10.4. Use FSExchangeObjects instead.}
10779 {
10780 * FSpExchangeFiles() *** DEPRECATED ***
10781 *
10782 * Mac OS X threading:
10783 * Thread safe since version 10.0
10784 *
10785 * Availability:
10786 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10787 * CarbonLib: in CarbonLib 1.0 and later
10788 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10789 }
FSpExchangeFilesnull10790 function FSpExchangeFiles( const (*var*) source: FSSpec; const (*var*) dest: FSSpec ): OSErr; external name '_FSpExchangeFiles';
10791 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10792
10793
10794 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10795 {
10796 * PBShareSync() *** DEPRECATED ***
10797 *
10798 * Mac OS X threading:
10799 * Thread safe since version 10.0
10800 *
10801 * Availability:
10802 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10803 * CarbonLib: in CarbonLib 1.0 and later
10804 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10805 }
PBShareSyncnull10806 function PBShareSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBShareSync';
10807 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10808
10809
10810 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10811 {
10812 * PBShareAsync() *** DEPRECATED ***
10813 *
10814 * Mac OS X threading:
10815 * Thread safe since version 10.0
10816 *
10817 * Availability:
10818 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10819 * CarbonLib: in CarbonLib 1.0 and later
10820 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10821 }
PBShareAsyncnull10822 function PBShareAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBShareAsync';
10823 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10824
10825
10826 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10827 {
10828 * PBUnshareSync() *** DEPRECATED ***
10829 *
10830 * Mac OS X threading:
10831 * Thread safe since version 10.0
10832 *
10833 * Availability:
10834 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10835 * CarbonLib: in CarbonLib 1.0 and later
10836 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10837 }
PBUnshareSyncnull10838 function PBUnshareSync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBUnshareSync';
10839 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10840
10841
10842 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10843 {
10844 * PBUnshareAsync() *** DEPRECATED ***
10845 *
10846 * Mac OS X threading:
10847 * Thread safe since version 10.0
10848 *
10849 * Availability:
10850 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10851 * CarbonLib: in CarbonLib 1.0 and later
10852 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10853 }
PBUnshareAsyncnull10854 function PBUnshareAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBUnshareAsync';
10855 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10856
10857
10858 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10859 {
10860 * PBGetUGEntrySync() *** DEPRECATED ***
10861 *
10862 * Mac OS X threading:
10863 * Thread safe since version 10.0
10864 *
10865 * Availability:
10866 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10867 * CarbonLib: in CarbonLib 1.0 and later
10868 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10869 }
PBGetUGEntrySyncnull10870 function PBGetUGEntrySync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBGetUGEntrySync';
10871 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10872
10873
10874 { This function is deprecated in Mac OS X 10.4. It was never implemented on OS X.}
10875 {
10876 * PBGetUGEntryAsync() *** DEPRECATED ***
10877 *
10878 * Mac OS X threading:
10879 * Thread safe since version 10.0
10880 *
10881 * Availability:
10882 * Mac OS X: in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.4
10883 * CarbonLib: in CarbonLib 1.0 and later
10884 * Non-Carbon CFM: in InterfaceLib 7.1 and later
10885 }
PBGetUGEntryAsyncnull10886 function PBGetUGEntryAsync( paramBlock: HParmBlkPtr ): OSErr; external name '_PBGetUGEntryAsync';
10887 (* __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_4, __IPHONE_NA, __IPHONE_NA) *)
10888
10889 {$endc} {not TARGET_CPU_64}
10890
10891 {$endc} {TARGET_OS_MAC}
10892
10893 {$ifc not defined MACOSALLINCLUDE or not MACOSALLINCLUDE}
10894
10895 end.
10896 {$endc} {not MACOSALLINCLUDE}
10897