]> git.saurik.com Git - wxWidgets.git/blob - src/mac/morefile/DirectoryCopy.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Warning fixes (still does not compile).
[wxWidgets.git] / src / mac / morefile / DirectoryCopy.c
1 /*
2 File: DirectoryCopy.c
3
4 Contains: A robust, general purpose directory copy routine.
5
6 Version: MoreFiles
7
8 Copyright: © 1992-2001 by Apple Computer, Inc., all rights reserved.
9
10 You may incorporate this sample code into your applications without
11 restriction, though the sample code has been provided "AS IS" and the
12 responsibility for its operation is 100% yours. However, what you are
13 not permitted to do is to redistribute the source as "DSC Sample Code"
14 after having made changes. If you're going to re-distribute the source,
15 we require that you make it clear in the source that the code was
16 descended from Apple Sample Code, but that you've made changes.
17
18 File Ownership:
19
20 DRI: Apple Macintosh Developer Technical Support
21
22 Other Contact: Apple Macintosh Developer Technical Support
23 <http://developer.apple.com/bugreporter/>
24
25 Technology: DTS Sample Code
26
27 Writers:
28
29 (JL) Jim Luther
30
31 Change History (most recent first):
32
33 <2> 2/7/01 JL Added standard header. Updated names of includes.
34 <1> 12/06/99 JL MoreFiles 1.5.
35 */
36
37 #include <MacTypes.h>
38 #include <MacErrors.h>
39 #include <MacMemory.h>
40 #include <Files.h>
41 #include <Script.h>
42 #include <Math64.h>
43
44 #define __COMPILINGMOREFILES
45
46 #include "MoreFiles.h"
47 #include "MoreFilesExtras.h"
48 #include "MoreDesktopMgr.h"
49 #include "FileCopy.h"
50 #include "DirectoryCopy.h"
51
52 /*****************************************************************************/
53
54 /* local constants */
55
56 enum
57 {
58 dirCopyBigCopyBuffSize = 0x00004000,
59 dirCopyMinCopyBuffSize = 0x00000200
60 };
61
62
63 /*****************************************************************************/
64
65 /* local data structures */
66
67 /* The EnumerateGlobals structure is used to minimize the amount of
68 ** stack space used when recursively calling CopyLevel and to hold
69 ** global information that might be needed at any time. */
70
71 #if PRAGMA_STRUCT_ALIGN
72 #pragma options align=mac68k
73 #endif
74 struct EnumerateGlobals
75 {
76 Ptr copyBuffer; /* pointer to buffer used for file copy operations */
77 long bufferSize; /* the size of the copy buffer */
78 CopyErrProcPtr errorHandler; /* pointer to error handling function */
79 CopyFilterProcPtr copyFilterProc; /* pointer to filter function */
80 OSErr error; /* temporary holder of results - saves 2 bytes of stack each level */
81 Boolean bailout; /* set to true to by error handling function if fatal error */
82 short destinationVRefNum; /* the destination vRefNum */
83 Str63 itemName; /* the name of the current item */
84 CInfoPBRec myCPB; /* the parameter block used for PBGetCatInfo calls */
85 };
86 #if PRAGMA_STRUCT_ALIGN
87 #pragma options align=reset
88 #endif
89
90 typedef struct EnumerateGlobals EnumerateGlobals;
91 typedef EnumerateGlobals *EnumerateGlobalsPtr;
92
93
94 /* The PreflightGlobals structure is used to minimize the amount of
95 ** stack space used when recursively calling GetLevelSize and to hold
96 ** global information that might be needed at any time. */
97
98 #if PRAGMA_STRUCT_ALIGN
99 #pragma options align=mac68k
100 #endif
101 struct PreflightGlobals
102 {
103 OSErr result; /* temporary holder of results - saves 2 bytes of stack each level */
104 Str63 itemName; /* the name of the current item */
105 CInfoPBRec myCPB; /* the parameter block used for PBGetCatInfo calls */
106
107 unsigned long dstBlksPerAllocBlk; /* the number of 512 byte blocks per allocation block on destination */
108
109 unsigned long allocBlksNeeded; /* the total number of allocation blocks needed */
110
111 unsigned long tempBlocks; /* temporary storage for calculations (save some stack space) */
112 CopyFilterProcPtr copyFilterProc; /* pointer to filter function */
113 };
114 #if PRAGMA_STRUCT_ALIGN
115 #pragma options align=reset
116 #endif
117
118 typedef struct PreflightGlobals PreflightGlobals;
119 typedef PreflightGlobals *PreflightGlobalsPtr;
120
121 /*****************************************************************************/
122
123 /* static prototypes */
124
125 static void GetLevelSize(long currentDirID,
126 PreflightGlobals *theGlobals);
127
128 static OSErr PreflightDirectoryCopySpace(short srcVRefNum,
129 long srcDirID,
130 short dstVRefNum,
131 CopyFilterProcPtr copyFilterProc,
132 Boolean *spaceOK);
133
134 static void CopyLevel(long sourceDirID,
135 long dstDirID,
136 EnumerateGlobals *theGlobals);
137
138 /*****************************************************************************/
139
140 static void GetLevelSize(long currentDirID,
141 PreflightGlobals *theGlobals)
142 {
143 short index = 1;
144
145 do
146 {
147 theGlobals->myCPB.dirInfo.ioFDirIndex = index;
148 theGlobals->myCPB.dirInfo.ioDrDirID = currentDirID; /* we need to do this every time */
149 /* through, since GetCatInfo */
150 /* returns ioFlNum in this field */
151 theGlobals->result = PBGetCatInfoSync(&theGlobals->myCPB);
152 if ( theGlobals->result == noErr )
153 {
154 if ( (theGlobals->copyFilterProc == NULL) ||
155 CallCopyFilterProc(theGlobals->copyFilterProc, &theGlobals->myCPB) ) /* filter if filter proc was supplied */
156 {
157 /* Either there's no filter proc OR the filter proc says to use this item */
158 if ( (theGlobals->myCPB.dirInfo.ioFlAttrib & kioFlAttribDirMask) != 0 )
159 {
160 /* we have a directory */
161
162 GetLevelSize(theGlobals->myCPB.dirInfo.ioDrDirID, theGlobals); /* recurse */
163 theGlobals->result = noErr; /* clear error return on way back */
164 }
165 else
166 {
167 /* We have a file - add its allocation blocks to allocBlksNeeded. */
168 /* Since space on Mac OS disks is always allocated in allocation blocks, */
169 /* this takes into account rounding up to the end of an allocation block. */
170
171 /* get number of 512-byte blocks needed for data fork */
172 if ( ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlLgLen & 0x000001ff) != 0 )
173 {
174 theGlobals->tempBlocks = ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlLgLen >> 9) + 1;
175 }
176 else
177 {
178 theGlobals->tempBlocks = (unsigned long)theGlobals->myCPB.hFileInfo.ioFlLgLen >> 9;
179 }
180 /* now, calculate number of new allocation blocks needed for the data fork and add it to the total */
181 if ( theGlobals->tempBlocks % theGlobals->dstBlksPerAllocBlk )
182 {
183 theGlobals->allocBlksNeeded += (theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk) + 1;
184 }
185 else
186 {
187 theGlobals->allocBlksNeeded += theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk;
188 }
189
190 /* get number of 512-byte blocks needed for resource fork */
191 if ( ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlRLgLen & 0x000001ff) != 0 )
192 {
193 theGlobals->tempBlocks = ((unsigned long)theGlobals->myCPB.hFileInfo.ioFlRLgLen >> 9) + 1;
194 }
195 else
196 {
197 theGlobals->tempBlocks = (unsigned long)theGlobals->myCPB.hFileInfo.ioFlRLgLen >> 9;
198 }
199 /* now, calculate number of new allocation blocks needed for the resource fork and add it to the total */
200 if ( theGlobals->tempBlocks % theGlobals->dstBlksPerAllocBlk )
201 {
202 theGlobals->allocBlksNeeded += (theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk) + 1;
203 }
204 else
205 {
206 theGlobals->allocBlksNeeded += theGlobals->tempBlocks / theGlobals->dstBlksPerAllocBlk;
207 }
208 }
209 }
210 }
211 ++index;
212 } while ( theGlobals->result == noErr );
213 }
214
215 /*****************************************************************************/
216
217 static OSErr PreflightDirectoryCopySpace(short srcVRefNum,
218 long srcDirID,
219 short dstVRefNum,
220 CopyFilterProcPtr copyFilterProc,
221 Boolean *spaceOK)
222 {
223 XVolumeParam pb;
224 OSErr error;
225 unsigned long dstFreeBlocks;
226 PreflightGlobals theGlobals;
227
228 error = XGetVolumeInfoNoName(NULL, dstVRefNum, &pb);
229 if ( error == noErr )
230 {
231 /* Convert freeBytes to free disk blocks (512-byte blocks) */
232 dstFreeBlocks = U32SetU(U64ShiftRight(pb.ioVFreeBytes, 9));
233
234 /* get allocation block size (always multiple of 512) and divide by 512
235 to get number of 512-byte blocks per allocation block */
236 theGlobals.dstBlksPerAllocBlk = ((unsigned long)pb.ioVAlBlkSiz >> 9);
237
238 theGlobals.allocBlksNeeded = 0;
239
240 theGlobals.myCPB.dirInfo.ioNamePtr = theGlobals.itemName;
241 theGlobals.myCPB.dirInfo.ioVRefNum = srcVRefNum;
242
243 theGlobals.copyFilterProc = copyFilterProc;
244
245 GetLevelSize(srcDirID, &theGlobals);
246
247 /* Is there enough room on the destination volume for the source file? */
248 /* Note: This will work because the largest number of disk blocks supported */
249 /* on a 2TB volume is 0xffffffff and (allocBlksNeeded * dstBlksPerAllocBlk) */
250 /* will always be less than 0xffffffff. */
251 *spaceOK = ((theGlobals.allocBlksNeeded * theGlobals.dstBlksPerAllocBlk) <= dstFreeBlocks);
252 }
253
254 return ( error );
255 }
256
257 /*****************************************************************************/
258
259 static void CopyLevel(long sourceDirID,
260 long dstDirID,
261 EnumerateGlobals *theGlobals)
262 {
263 long currentSrcDirID = 0 ;
264 long newDirID;
265 short index = 1;
266
267 do
268 {
269 /* Get next source item at the current directory level */
270
271 theGlobals->myCPB.dirInfo.ioFDirIndex = index;
272 theGlobals->myCPB.dirInfo.ioDrDirID = sourceDirID;
273 theGlobals->error = PBGetCatInfoSync(&theGlobals->myCPB);
274
275 if ( theGlobals->error == noErr )
276 {
277 if ( (theGlobals->copyFilterProc == NULL) ||
278 CallCopyFilterProc(theGlobals->copyFilterProc, &theGlobals->myCPB) ) /* filter if filter proc was supplied */
279 {
280 /* Either there's no filter proc OR the filter proc says to use this item */
281
282 /* We have an item. Is it a file or directory? */
283 if ( (theGlobals->myCPB.hFileInfo.ioFlAttrib & kioFlAttribDirMask) != 0 )
284 {
285 /* We have a directory */
286
287 /* Create a new directory at the destination. No errors allowed! */
288 theGlobals->error = DirCreate(theGlobals->destinationVRefNum, dstDirID, theGlobals->itemName, &newDirID);
289 if ( theGlobals->error == noErr )
290 {
291 /* Save the current source directory ID where we can get it when we come back
292 ** from recursion land. */
293 currentSrcDirID = theGlobals->myCPB.dirInfo.ioDrDirID;
294
295 /* Dive again (copy the directory level we just found below this one) */
296 CopyLevel(theGlobals->myCPB.dirInfo.ioDrDirID, newDirID, theGlobals);
297
298 if ( !theGlobals->bailout )
299 {
300 /* Copy comment from old to new directory. */
301 /* Ignore the result because we really don't care if it worked or not. */
302 (void) DTCopyComment(theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL, theGlobals->destinationVRefNum, newDirID, NULL);
303
304 /* Copy directory attributes (dates, etc.) to newDirID. */
305 /* No errors allowed */
306 theGlobals->error = CopyFileMgrAttributes(theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL, theGlobals->destinationVRefNum, newDirID, NULL, true);
307
308 /* handle any errors from CopyFileMgrAttributes */
309 if ( theGlobals->error != noErr )
310 {
311 if ( theGlobals->errorHandler != NULL )
312 {
313 theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, copyDirFMAttributesOp,
314 theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL,
315 theGlobals->destinationVRefNum, newDirID, NULL);
316 }
317 else
318 {
319 /* If you don't handle the errors with an error handler, */
320 /* then the copy stops here. */
321 theGlobals->bailout = true;
322 }
323 }
324 }
325 }
326 else /* error handling for DirCreate */
327 {
328 /* note that currentSrcDirID has not been initialised when entering this execution path */
329 if ( theGlobals->errorHandler != NULL )
330 {
331 theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, dirCreateOp,
332 theGlobals->myCPB.dirInfo.ioVRefNum, currentSrcDirID, NULL,
333 theGlobals->destinationVRefNum, dstDirID, theGlobals->itemName);
334 }
335 else
336 {
337 /* If you don't handle the errors with an error handler, */
338 /* then the copy stops here. */
339 theGlobals->bailout = true;
340 }
341 }
342
343 if ( !theGlobals->bailout )
344 {
345 /* clear error return on way back if we aren't bailing out */
346 theGlobals->error = noErr;
347 }
348 }
349 else
350 {
351 /* We have a file, so copy it */
352
353 theGlobals->error = FileCopy(theGlobals->myCPB.hFileInfo.ioVRefNum,
354 theGlobals->myCPB.hFileInfo.ioFlParID,
355 theGlobals->itemName,
356 theGlobals->destinationVRefNum,
357 dstDirID,
358 NULL,
359 NULL,
360 theGlobals->copyBuffer,
361 theGlobals->bufferSize,
362 false);
363
364 /* handle any errors from FileCopy */
365 if ( theGlobals->error != noErr )
366 {
367 if ( theGlobals->errorHandler != NULL )
368 {
369 theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, fileCopyOp,
370 theGlobals->myCPB.hFileInfo.ioVRefNum, theGlobals->myCPB.hFileInfo.ioFlParID, theGlobals->itemName,
371 theGlobals->destinationVRefNum, dstDirID, NULL);
372 if ( !theGlobals->bailout )
373 {
374 /* If the CopyErrProc handled the problem, clear the error here */
375 theGlobals->error = noErr;
376 }
377 }
378 else
379 {
380 /* If you don't handle the errors with an error handler, */
381 /* then the copy stops here. */
382 theGlobals->bailout = true;
383 }
384 }
385 }
386 }
387 }
388 else
389 { /* error handling for PBGetCatInfo */
390 /* it's normal to get a fnfErr when indexing; that only means you've hit the end of the directory */
391 if ( theGlobals->error != fnfErr )
392 {
393 if ( theGlobals->errorHandler != NULL )
394 {
395 theGlobals->bailout = CallCopyErrProc(theGlobals->errorHandler, theGlobals->error, getNextItemOp,
396 theGlobals->myCPB.dirInfo.ioVRefNum, sourceDirID, NULL, 0, 0, NULL);
397 if ( !theGlobals->bailout )
398 {
399 /* If the CopyErrProc handled the problem, clear the error here */
400 theGlobals->error = noErr;
401 }
402 }
403 else
404 {
405 /* If you don't handle the errors with an error handler, */
406 /* then the copy stops here. */
407 theGlobals->bailout = true;
408 }
409 }
410 }
411 ++index; /* prepare to get next item */
412 } while ( (theGlobals->error == noErr) && (!theGlobals->bailout) ); /* time to fall back a level? */
413 }
414
415 /*****************************************************************************/
416
417 pascal OSErr FilteredDirectoryCopy(short srcVRefNum,
418 long srcDirID,
419 ConstStr255Param srcName,
420 short dstVRefNum,
421 long dstDirID,
422 ConstStr255Param dstName,
423 ConstStr255Param copyName,
424 void *copyBufferPtr,
425 long copyBufferSize,
426 Boolean preflight,
427 CopyErrProcPtr copyErrHandler,
428 CopyFilterProcPtr copyFilterProc)
429 {
430 EnumerateGlobals theGlobals;
431 Boolean isDirectory;
432 OSErr error;
433 Boolean ourCopyBuffer = false;
434 Str63 srcDirName, oldDiskName;
435 Boolean spaceOK;
436
437 /* Make sure a copy buffer is allocated. */
438 if ( copyBufferPtr == NULL )
439 {
440 /* The caller didn't supply a copy buffer so grab one from the application heap.
441 ** Try to get a big copy buffer, if we can't, try for a 512-byte buffer.
442 ** If 512 bytes aren't available, we're in trouble. */
443 copyBufferSize = dirCopyBigCopyBuffSize;
444 copyBufferPtr = NewPtr(copyBufferSize);
445 if ( copyBufferPtr == NULL )
446 {
447 copyBufferSize = dirCopyMinCopyBuffSize;
448 copyBufferPtr = NewPtr(copyBufferSize);
449 if ( copyBufferPtr == NULL )
450 {
451 return ( memFullErr );
452 }
453 }
454 ourCopyBuffer = true;
455 }
456
457 /* Get the real dirID where we're copying from and make sure it is a directory. */
458 error = GetDirectoryID(srcVRefNum, srcDirID, srcName, &srcDirID, &isDirectory);
459 if ( error != noErr )
460 {
461 goto ErrorExit;
462 }
463 if ( !isDirectory )
464 {
465 error = dirNFErr;
466 goto ErrorExit;
467 }
468
469 /* Special case destination if it is the root parent directory. */
470 /* Since you can't create the root directory, this is needed if */
471 /* you want to copy a directory's content to a disk's root directory. */
472 if ( (dstDirID == fsRtParID) && (dstName == NULL) )
473 {
474 dstDirID = fsRtParID;
475 isDirectory = true;
476 error = noErr;
477 }
478 else
479 {
480 /* Get the real dirID where we're going to put the copy and make sure it is a directory. */
481 error = GetDirectoryID(dstVRefNum, dstDirID, dstName, &dstDirID, &isDirectory);
482 if ( error != noErr )
483 {
484 goto ErrorExit;
485 }
486 if ( !isDirectory )
487 {
488 error = dirNFErr;
489 goto ErrorExit;
490 }
491 }
492
493 /* Get the real vRefNum of both the source and destination */
494 error = DetermineVRefNum(srcName, srcVRefNum, &srcVRefNum);
495 if ( error != noErr )
496 {
497 goto ErrorExit;
498 }
499 error = DetermineVRefNum(dstName, dstVRefNum, &dstVRefNum);
500 if ( error != noErr )
501 {
502 goto ErrorExit;
503 }
504
505 if ( preflight )
506 {
507 error = PreflightDirectoryCopySpace(srcVRefNum, srcDirID, dstVRefNum, copyFilterProc, &spaceOK);
508 if ( error != noErr )
509 {
510 goto ErrorExit;
511 }
512 if ( !spaceOK )
513 {
514 error = dskFulErr; /* not enough room on destination */
515 goto ErrorExit;
516 }
517 }
518
519 /* Create the new directory in the destination directory with the */
520 /* same name as the source directory. */
521 error = GetDirName(srcVRefNum, srcDirID, srcDirName);
522 if ( error != noErr )
523 {
524 goto ErrorExit;
525 }
526
527 /* Again, special case destination if the destination is the */
528 /* root parent directory. This time, we'll rename the disk to */
529 /* the source directory name. */
530 if ( dstDirID == fsRtParID )
531 {
532 /* Get the current name of the destination disk */
533 error = GetDirName(dstVRefNum, fsRtDirID, oldDiskName);
534 if ( error == noErr )
535 {
536 /* use the copyName as srcDirName if supplied */
537 if ( copyName != NULL )
538 {
539 /* make a copy since copyName is a const input */
540 BlockMoveData(copyName, srcDirName, sizeof(Str31));
541 }
542 /* Shorten the name if it's too long to be the volume name */
543 TruncPString(srcDirName, srcDirName, 27);
544
545 /* Rename the disk */
546 error = HRename(dstVRefNum, fsRtParID, oldDiskName, srcDirName);
547
548 /* and copy to the root directory */
549 dstDirID = fsRtDirID;
550 }
551 }
552 else
553 {
554 /* use the copyName as srcDirName if supplied */
555 error = DirCreate(dstVRefNum, dstDirID, ((copyName != NULL) ? copyName : srcDirName), &dstDirID);
556 }
557 if ( error != noErr )
558 {
559 /* handle any errors from DirCreate */
560 if ( copyErrHandler != NULL )
561 {
562 if ( CallCopyErrProc(copyErrHandler, error, dirCreateOp,
563 srcVRefNum, srcDirID, NULL,
564 dstVRefNum, dstDirID, srcDirName) )
565 {
566 goto ErrorExit;
567 }
568 else
569 {
570 /* If the CopyErrProc handled the problem, clear the error here */
571 /* and continue */
572 error = noErr;
573 }
574 }
575 else
576 {
577 /* If you don't handle the errors with an error handler, */
578 /* then the copy stops here. */
579 goto ErrorExit;
580 }
581 }
582
583 /* dstDirID is now the newly created directory! */
584
585 /* Set up the globals we need to access from the recursive routine. */
586 theGlobals.copyBuffer = (Ptr)copyBufferPtr;
587 theGlobals.bufferSize = copyBufferSize;
588 theGlobals.destinationVRefNum = dstVRefNum; /* so we can get to it always */
589 theGlobals.myCPB.hFileInfo.ioNamePtr = (StringPtr)&theGlobals.itemName;
590 theGlobals.myCPB.hFileInfo.ioVRefNum = srcVRefNum;
591 theGlobals.errorHandler = copyErrHandler;
592 theGlobals.bailout = false;
593 theGlobals.copyFilterProc = copyFilterProc;
594
595 /* Here we go into recursion land... */
596 CopyLevel(srcDirID, dstDirID, &theGlobals);
597 error = theGlobals.error; /* get the result */
598
599 if ( !theGlobals.bailout )
600 {
601 /* Copy comment from source to destination directory. */
602 /* Ignore the result because we really don't care if it worked or not. */
603 (void) DTCopyComment(srcVRefNum, srcDirID, NULL, dstVRefNum, dstDirID, NULL);
604
605 /* Copy the File Manager attributes */
606 error = CopyFileMgrAttributes(srcVRefNum, srcDirID, NULL,
607 dstVRefNum, dstDirID, NULL, true);
608
609 /* handle any errors from CopyFileMgrAttributes */
610 if ( (error != noErr) && (copyErrHandler != NULL) )
611 {
612 theGlobals.bailout = CallCopyErrProc(copyErrHandler, error, copyDirFMAttributesOp,
613 srcVRefNum, srcDirID, NULL,
614 dstVRefNum, dstDirID, NULL);
615 }
616 }
617
618 ErrorExit:
619 /* Get rid of the copy buffer if we allocated it. */
620 if ( ourCopyBuffer )
621 {
622 DisposePtr((Ptr)copyBufferPtr);
623 }
624
625 return ( error );
626 }
627
628 /*****************************************************************************/
629
630 pascal OSErr DirectoryCopy(short srcVRefNum,
631 long srcDirID,
632 ConstStr255Param srcName,
633 short dstVRefNum,
634 long dstDirID,
635 ConstStr255Param dstName,
636 ConstStr255Param copyName,
637 void *copyBufferPtr,
638 long copyBufferSize,
639 Boolean preflight,
640 CopyErrProcPtr copyErrHandler)
641 {
642 return ( FilteredDirectoryCopy(srcVRefNum, srcDirID, srcName,
643 dstVRefNum, dstDirID, dstName,
644 copyName,
645 copyBufferPtr, copyBufferSize, preflight,
646 copyErrHandler, NULL) );
647 }
648
649 /*****************************************************************************/
650
651 pascal OSErr FSpFilteredDirectoryCopy(const FSSpec *srcSpec,
652 const FSSpec *dstSpec,
653 ConstStr255Param copyName,
654 void *copyBufferPtr,
655 long copyBufferSize,
656 Boolean preflight,
657 CopyErrProcPtr copyErrHandler,
658 CopyFilterProcPtr copyFilterProc)
659 {
660 return ( FilteredDirectoryCopy(srcSpec->vRefNum, srcSpec->parID, srcSpec->name,
661 dstSpec->vRefNum, dstSpec->parID, dstSpec->name,
662 copyName,
663 copyBufferPtr, copyBufferSize, preflight,
664 copyErrHandler, copyFilterProc) );
665 }
666
667 /*****************************************************************************/
668
669 pascal OSErr FSpDirectoryCopy(const FSSpec *srcSpec,
670 const FSSpec *dstSpec,
671 ConstStr255Param copyName,
672 void *copyBufferPtr,
673 long copyBufferSize,
674 Boolean preflight,
675 CopyErrProcPtr copyErrHandler)
676 {
677 return ( FilteredDirectoryCopy(srcSpec->vRefNum, srcSpec->parID, srcSpec->name,
678 dstSpec->vRefNum, dstSpec->parID, dstSpec->name,
679 copyName,
680 copyBufferPtr, copyBufferSize, preflight,
681 copyErrHandler, NULL) );
682 }
683
684 /*****************************************************************************/
685
wxWidgets (Impactor)