int __PHYSFS_platformClose(void *opaque)
{
SInt16 ref = *((SInt16 *) opaque);
SInt16 vRefNum;
Str63 volName;
int flushVol = 0;
if (GetVRefNum(ref, &vRefNum) == noErr)
{
HParamBlockRec hpbr;
memset(&hpbr, '\0', sizeof (HParamBlockRec));
hpbr.volumeParam.ioNamePtr = volName;
hpbr.volumeParam.ioVRefNum = vRefNum;
hpbr.volumeParam.ioVolIndex = 0;
if (PBHGetVInfoSync(&hpbr) == noErr)
flushVol = 1;
} /* if */
BAIL_IF_MACRO(oserr(FSClose(ref)) != noErr, NULL, 0);
free(opaque);
if (flushVol)
FlushVol(volName, vRefNum); /* update catalog info, etc. */
return(1);
} /* __PHYSFS_platformClose */
Boolean PICloseFileAndMakeAlias (FSSpec& fsSpec,
FileHandle fRefNum, Boolean sameNames,
Boolean *dirty, AliasHandle *alias, short *result)
{
// FSSpec spec;
OSErr gotErr;
// Close the file if it is open.
if (fRefNum != 0)
(void) TestAndStoreResult (result, FSClose (fRefNum));
// Delete the file if we had an error.
if (*result != noErr)
(void) FSpDelete (&fsSpec);
// Flush the volume anyway.
if (!TestAndStoreResult (result, FlushVol (NULL, fsSpec.vRefNum))) return FALSE;
// Mark the file as clean.
*dirty = FALSE;
/* create alias for scripting system */
if (sameNames)
{ // didn't enter new filename, so set filename to nothing
fsSpec.name[ (fsSpec.name[0] = 0)+1 ] = 0;
} // otherwise use filename and store entire reference
gotErr = NewAlias(nil, &fsSpec, alias);
return (gotErr == noErr);
}
int asyncFileClose(AsyncFile *f) {
/* Close the given asynchronous file. */
AsyncFileState *state;
short int volRefNum;
OSErr err;
if (!asyncFileValid(f)) return 0; /* already closed */
state = f->state;
err = GetVRefNum(state->refNum, &volRefNum);
success(err == noErr);
err = FSClose(state->refNum);
success(err == noErr);
if (!interpreterProxy->failed()) err = FlushVol(NULL, volRefNum);
success(err == noErr);
if (asyncFileCompletionProc != nil)
DisposeIOCompletionUPP(asyncFileCompletionProc);
asyncFileCompletionProc = nil;
if (state->bufferPtr != nil) DisposePtr(state->bufferPtr);
DisposePtr((void *) f->state);
f->state = nil;
f->sessionID = 0;
return 0;
}
void sync( void )
{
int i = 0;
OSErr err;
do
{
HParamBlockRec pb;
pb.volumeParam.ioNamePtr = NULL;
pb.volumeParam.ioVRefNum = 0;
pb.volumeParam.ioVolIndex = ++i;
err = PBHGetVInfoSync( &pb );
if ( err == noErr )
{
err = FlushVol( NULL, pb.volumeParam.ioVRefNum );
}
}
while ( err != nsvErr );
}
OSErr CreateToolNameRes(StringPtr toolName) {
short ref;
FSSpec prefs;
OSErr error;
Handle theStrings;
// build the 'STR ' resource
error = FindPrefs(&prefs);
if (error == noErr) {
ref = FSpOpenResFile(&prefs, fsRdWrPerm);
if (ref != -1) {
theStrings = Get1Resource('STR ',kToolNameRes);
if (theStrings != nil) {
RemoveResource(theStrings);
error = ResError();
}
error = PtrToHand(toolName, &theStrings, toolName[0] + 1);
AddResource(theStrings, 'STR ', kToolNameRes, "\ptoolName");
error = ResError();
ChangedResource(theStrings);
error = ResError();
WriteResource(theStrings);
error = ResError();
//ReleaseResource(theStrings); // Release the resource from memory.
//error = ResError();
UpdateResFile(ref); // No screwing around; write that resource!
error = ResError();
FlushVol(nil, prefs.vRefNum);
CloseResFile(ref);
} else {
OSErr QTInfo_MakeFilePreview (Movie theMovie, short theRefNum, ICMProgressProcRecordPtr theProgressProc)
{
unsigned long myModDate;
PreviewResourceRecord myPNOTRecord;
long myEOF;
long mySize;
unsigned long myAtomHeader[2]; // an atom header: size and type
OSType myPreviewType;
OSErr myErr = noErr;
//////////
//
// determine whether theRefNum is a file reference number of a data fork or a resource fork;
// if it's a resource fork, then we'll just call the existing ICM function MakeFilePreview
//
//////////
if (QTInfo_IsRefNumOfResourceFork(theRefNum)) {
myErr = MakeFilePreview(theRefNum, theProgressProc);
goto bail;
}
//////////
//
// determine the preview type
//
//////////
// if the movie has a movie preview, use that as the file preview; otherwise use a thumbnail
// of the movie poster frame as the file preview
if (QTInfo_MovieHasPreview(theMovie))
myPreviewType = MovieAID;
else
myPreviewType = kQTFileTypePicture;
//////////
//
// construct the 'pnot' atom
//
//////////
// fill in the 'pnot' atom header
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + sizeof(myPNOTRecord));
myAtomHeader[1] = EndianU32_NtoB(ShowFilePreviewComponentType);
// fill in the 'pnot' atom data
GetDateTime(&myModDate);
myPNOTRecord.modDate = EndianU32_NtoB(myModDate); // the modification time of the preview
myPNOTRecord.version = EndianS16_NtoB(0); // version number; must be 0
myPNOTRecord.resType = EndianU32_NtoB(myPreviewType); // atom type containing preview
myPNOTRecord.resID = EndianS16_NtoB(1); // the 1-based index of the atom of the specified type to use
//////////
//
// write the 'pnot' atom at the end of the data fork
//
//////////
// get the current logical end-of-file and extend it by the desired amount
myErr = GetEOF(theRefNum, &myEOF);
if (myErr != noErr)
goto bail;
myErr = SetEOF(theRefNum, myEOF + sizeof(myAtomHeader) + sizeof(myPNOTRecord));
if (myErr != noErr)
goto bail;
// set the file mark
myErr = SetFPos(theRefNum, fsFromStart, myEOF);
if (myErr != noErr)
goto bail;
// write the atom header into the file
mySize = sizeof(myAtomHeader);
myErr = FSWrite(theRefNum, &mySize, myAtomHeader);
if (myErr != noErr)
goto bail;
// write the atom data into the file
mySize = sizeof(myPNOTRecord);
myErr = FSWrite(theRefNum, &mySize, &myPNOTRecord);
if (myErr != noErr)
goto bail;
//////////
//
// write the preview data atom at the end of the data fork
//
//////////
if (myPreviewType == MovieAID) {
// in theory, we don't need to do anything here, since our 'pnot' atom points
// to the 'moov' atom; in practice, this doesn't work correctly (it seems like
// a bug in StandardGetFilePreview)
}
if (myPreviewType == kQTFileTypePicture) {
PicHandle myPicture = NULL;
PicHandle myThumbnail = NULL;
// get the poster frame picture
myPicture = GetMoviePosterPict(theMovie);
if (myPicture != NULL) {
// create a thumbnail
myThumbnail = (PicHandle)NewHandleClear(4);
if (myThumbnail != NULL) {
myErr = MakeThumbnailFromPicture(myPicture, 0, myThumbnail, theProgressProc);
if (myErr == noErr) {
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + GetHandleSize((Handle)myThumbnail));
myAtomHeader[1] = EndianU32_NtoB(myPreviewType);
// write the atom header into the file
mySize = sizeof(myAtomHeader);
myErr = FSWrite(theRefNum, &mySize, myAtomHeader);
if (myErr == noErr) {
// write the atom data into the file
mySize = GetHandleSize((Handle)myThumbnail);
myErr = FSWrite(theRefNum, &mySize, *myThumbnail);
}
}
KillPicture(myThumbnail);
}
KillPicture(myPicture);
}
}
#if 0
// here's how you'd add a text preview; note that the text is hard-coded here....
if (myPreviewType == kQTFileTypeText) {
char myText[] = "The penguin gradually appears from the mist of the ice floe.";
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + strlen(myText));
myAtomHeader[1] = EndianU32_NtoB(myPreviewType);
// write the atom header into the file
mySize = sizeof(myAtomHeader);
myErr = FSWrite(theRefNum, &mySize, myAtomHeader);
if (myErr != noErr)
goto bail;
// write the atom data into the file
mySize = strlen(myText);
myErr = FSWrite(theRefNum, &mySize, myText);
if (myErr != noErr)
goto bail;
}
#endif
#if TARGET_OS_MAC
if (myErr == noErr) {
short myVolNum;
// flush the volume
myErr = GetVRefNum(theRefNum, &myVolNum);
if (myErr != noErr)
goto bail;
myErr = FlushVol(NULL, myVolNum);
}
#endif
bail:
return(myErr);
}
/* create file with IPIcon */
OSErr MakeFileWithIPIcon(const FSSpec *theFile,const IPIconRec *ipIcon)
{
OSErr err;
FInfo fndrInfo;
short refNum;
IconActionUPP addIconUPP;
MyIconResRec newIcon;
/* create a file */
err=FSpGetFInfo(theFile,&fndrInfo);
if (err==fnfErr)
FSpCreateResFile(theFile,kResEditCreator,kResourceFileType,smSystemScript);
if (err!=fnfErr && err!=noErr) return err;
/* open the file */
refNum=FSpOpenResFile(theFile,fsWrPerm);
if (refNum < 0) /* could not open -> the file has no resource fork */
{
FSpCreateResFile(theFile,fndrInfo.fdCreator,fndrInfo.fdType,smSystemScript);
refNum=FSpOpenResFile(theFile,fsWrPerm);
}
if (refNum < 0) /* could not open -> error */
return refNum;
UseResFile(refNum);
/* information for icon */
newIcon.resID=kCustomIconResource;
GetIndString(newIcon.resName,141,2);
newIcon.attrs=0;
/* save icon family(separated icons) */
if (ipIcon->iconSuite != NULL)
{
addIconUPP=NewIconActionUPP(AddIconToFile);
err=ForEachIconDo(ipIcon->iconSuite,GetMySelector(),addIconUPP,&newIcon);
DisposeIconActionUPP(addIconUPP);
}
/* save icns(single icon) */
if (isIconServicesAvailable)
{
IconFamilyHandle iconFamily;
err=IPIconToIconFamily(ipIcon,&iconFamily);
if (err==noErr)
{
SaveDataToResource(*iconFamily,GetHandleSize((Handle)iconFamily),
kIconFamilyType,newIcon.resID,newIcon.resName,newIcon.attrs);
DisposeHandle((Handle)iconFamily);
}
}
else
/* delete icns resource */
DeleteIconFamilyResource();
CloseResFile(refNum);
UseResFile(gApplRefNum);
/* set flag for custom icons */
err=FSpGetFInfo(theFile,&fndrInfo);
fndrInfo.fdFlags |= kHasCustomIcon;
fndrInfo.fdFlags &= ~kHasBeenInited;
err=FSpSetFInfo(theFile,&fndrInfo);
FlushVol(0L,theFile->vRefNum);
/* update file icon */
UpdateFinderIcon(theFile);
return err;
}
/* create folder with IPIcon */
OSErr MakeFolderWithIPIcon(const FSSpec *theFolder,const IPIconRec *ipIcon)
{
OSErr err;
long dirID;
FSSpec theIconFile;
Str15 iconFileName;
#ifdef __MOREFILESX__
FSRef fsRef;
#endif
/* create a folder */
err=FSpDirCreate(theFolder,smSystemScript,&dirID);
if (err==dupFNErr || err==dirNFErr)
{
Boolean isDirectory;
#ifdef __MOREFILESX__
err = FSpMakeFSRef(theFolder,&fsRef);
err = FSGetNodeID(&fsRef,&dirID,&isDirectory);
#else
err=FSpGetDirectoryID(theFolder,&dirID,&isDirectory);
#endif
if (!isDirectory) return -1;
}
if (err!=noErr) return err;
#ifdef __MOREFILESX__
err = FSpMakeFSRef(theFolder,&fsRef);
#endif
/* create icon file */
GetIndString(iconFileName,140,3);
err=FSMakeFSSpec(theFolder->vRefNum,dirID,iconFileName,&theIconFile);
if (err==fnfErr)
{
FInfo fndrInfo;
FSpCreateResFile(&theIconFile,kFinderCreator,'icon',smSystemScript);
err=FSpGetFInfo(&theIconFile,&fndrInfo);
fndrInfo.fdFlags |= kIsInvisible;
err=FSpSetFInfo(&theIconFile,&fndrInfo);
}
/* save icon data */
if (err==noErr)
{
short refNum;
IconActionUPP addIconUPP;
MyIconResRec newIcon;
#ifndef __MOREFILESX__
DInfo dInfo;
#endif
newIcon.resID=kCustomIconResource;
GetIndString(newIcon.resName,141,2);
newIcon.attrs=0;
refNum=FSpOpenResFile(&theIconFile,fsWrPerm);
UseResFile(refNum);
/* save icon family(separated icons) */
if (ipIcon->iconSuite != NULL)
{
addIconUPP = NewIconActionUPP(AddIconToFile);
err=ForEachIconDo(ipIcon->iconSuite,kSelectorMyData,addIconUPP,&newIcon);
DisposeIconActionUPP(addIconUPP);
}
/* save icns(single icon) */
if (isIconServicesAvailable)
{
IconFamilyHandle iconFamily;
err=IPIconToIconFamily(ipIcon,&iconFamily);
if (err==noErr)
{
SaveDataToResource(*iconFamily,GetHandleSize((Handle)iconFamily),
kIconFamilyType,newIcon.resID,newIcon.resName,newIcon.attrs);
DisposeHandle((Handle)iconFamily);
}
}
else
/* delete icns resource */
DeleteIconFamilyResource();
CloseResFile(refNum);
UseResFile(gApplRefNum);
/* set flag for custom icons */
#ifdef __MOREFILESX__
err = FSSetHasCustomIcon(&fsRef);
err = FSClearHasBeenInited(&fsRef);
#else
err=FSpGetDInfo(theFolder,&dInfo);
dInfo.frFlags |= kHasCustomIcon;
dInfo.frFlags &= ~kHasBeenInited;
err=FSpSetDInfo(theFolder,&dInfo);
#endif
gUsedCount.exportNum++;
}
FlushVol(0L,theFolder->vRefNum);
/* update folder icon */
UpdateFinderIcon(theFolder);
return err;
}
