OSErr PAS_decodeResource(PASEntry *entry, FSSpec *outFile, short inRefNum)
{
OSErr err = noErr;
short outRefNum;
PASResFork info;
SInt32 infoSize;
short oldResFile;
PASResource pasRes;
SInt32 pasResSize;
long bufSize;
Handle buffer;
long counter=0;
infoSize = sizeof(PASResFork);
err = SetFPos(inRefNum, fsFromStart, (*entry).entryOffset );
if (err != noErr) return err;
err = FSRead( inRefNum, &infoSize, &info);
if (err != noErr) return err;
if(infoSize != sizeof(PASResFork))
{
err = -1;
goto error;
}
oldResFile=CurResFile();
outRefNum = FSpOpenResFile(outFile, fsRdWrPerm);
if (outRefNum < noErr) return outRefNum;
UseResFile(outRefNum);
while (1)
{
pasResSize = sizeof(PASResource);
err = FSRead( inRefNum, &pasResSize, &pasRes);
if (err != noErr)
{
if(err == eofErr)
err = noErr;
break;
}
bufSize = pasRes.length;
buffer = NewHandle(bufSize);
HLock(buffer);
if(buffer == NULL)
{
// if we did not get our memory, try updateresfile
HUnlock(buffer);
UpdateResFile(outRefNum);
counter=0;
buffer = NewHandle(bufSize);
HLock(buffer);
if(buffer == NULL)
{
err = memFullErr;
break;
}
}
err = FSRead( inRefNum, &bufSize, &(**buffer));
if (err != noErr && err != eofErr) break;
AddResource(buffer, pasRes.attrType, pasRes.attrID, pasRes.attrName);
WriteResource(buffer);
SetResAttrs(buffer, pasRes.attr);
ChangedResource(buffer);
WriteResource(buffer);
ReleaseResource(buffer);
if (counter++ > 100)
{
UpdateResFile(outRefNum);
counter=0;
}
}
error:
UseResFile(oldResFile);
CloseResFile(outRefNum);
return err;
}
static void ErrorFini( void ) {
if( ResFlags & RF_OPENED ) {
CloseResFile( &hInstance );
}
}
bool Msg_Fini( void )
{
return( CloseResFile( &hInstance ) );
}
static int
WriteTextResource(
ClientData clientData, /* Not used. */
Tcl_Interp *interp, /* Current interpreter. */
int argc, /* Number of arguments. */
char **argv) /* Argument strings. */
{
char *errNum = "wrong # args: ";
char *errBad = "bad argument: ";
char *errStr;
char *fileName = NULL, *rsrcName = NULL;
char *data = NULL;
int rsrcID = -1, i;
short fileRef = -1;
OSErr err;
Handle dataHandle;
Str255 resourceName;
FSSpec fileSpec;
/*
* Process the arguments.
*/
for (i = 1 ; i < argc ; i++) {
if (!strcmp(argv[i], "-rsrc")) {
rsrcName = argv[i + 1];
i++;
} else if (!strcmp(argv[i], "-rsrcid")) {
rsrcID = atoi(argv[i + 1]);
i++;
} else if (!strcmp(argv[i], "-file")) {
fileName = argv[i + 1];
i++;
} else {
data = argv[i];
}
}
if ((rsrcName == NULL && rsrcID < 0) ||
(fileName == NULL) || (data == NULL)) {
errStr = errBad;
goto sourceFmtErr;
}
/*
* Open the resource file.
*/
err = FSpLocationFromPath(strlen(fileName), fileName, &fileSpec);
if (!(err == noErr || err == fnfErr)) {
Tcl_AppendResult(interp, "couldn't validate file name", (char *) NULL);
return TCL_ERROR;
}
if (err == fnfErr) {
FSpCreateResFile(&fileSpec, 'WIsH', 'rsrc', smSystemScript);
}
fileRef = FSpOpenResFile(&fileSpec, fsRdWrPerm);
if (fileRef == -1) {
Tcl_AppendResult(interp, "couldn't open resource file", (char *) NULL);
return TCL_ERROR;
}
UseResFile(fileRef);
/*
* Prepare data needed to create resource.
*/
if (rsrcID < 0) {
rsrcID = UniqueID('TEXT');
}
strcpy((char *) resourceName, rsrcName);
c2pstr((char *) resourceName);
dataHandle = NewHandle(strlen(data) + 1);
HLock(dataHandle);
strcpy(*dataHandle, data);
HUnlock(dataHandle);
/*
* Add the resource to the file and close it.
*/
AddResource(dataHandle, 'TEXT', rsrcID, resourceName);
UpdateResFile(fileRef);
CloseResFile(fileRef);
return TCL_OK;
sourceFmtErr:
Tcl_AppendResult(interp, errStr, "error in \"", argv[0], "\"",
(char *) NULL);
return TCL_ERROR;
}
int CALLBACK WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR theCmdLine, int nCmdShow)
{
HANDLE myAccel;
HWND myWindowFrame;
MSG myMsg;
WNDCLASSEX myWC;
char myFileName[MAX_PATH];
DWORD myLength;
OSErr myErr = noErr;
ghInst = hInstance;
gCmdLine = theCmdLine;
if (hPrevInstance == NULL) {
LoadString(hInstance, IDS_APPNAME, gAppName, sizeof(gAppName));
// register the frame window class
myWC.cbSize = sizeof(WNDCLASSEX);
myWC.style = CS_HREDRAW | CS_VREDRAW;
myWC.lpfnWndProc = (WNDPROC)QTFrame_FrameWndProc;
myWC.cbClsExtra = 0;
myWC.cbWndExtra = 0;
myWC.hInstance = hInstance;
myWC.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON));
myWC.hCursor = LoadCursor(NULL, IDC_ARROW);
myWC.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
myWC.lpszMenuName = gAppName;
myWC.lpszClassName = gAppName;
myWC.hIconSm = LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, 0);
if (!RegisterClassEx(&myWC)) {
if (!RegisterClass((LPWNDCLASS)&myWC.style))
return(0);
}
// register the movie child window class
myWC.cbSize = sizeof(WNDCLASSEX);
myWC.style = 0;
myWC.lpfnWndProc = (WNDPROC)QTFrame_MovieWndProc;
myWC.cbClsExtra = 0;
myWC.cbWndExtra = 0;
myWC.hInstance = hInstance;
myWC.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_CHILDICON));
// to avoid having QuickTime VR "fight" with the system over the cursor,
// we set the client area cursor to NULL; this means that for QuickTime
// movies, we'll need to change the cursor to an arrow manually; see the
// handling of the WM_MOUSEMOVE message in QTFrame_MovieWndProc
myWC.hCursor = NULL;
myWC.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
myWC.lpszMenuName = NULL;
myWC.lpszClassName = gChildName;
myWC.hIconSm = LoadImage(hInstance, MAKEINTRESOURCE(IDI_CHILDICON), IMAGE_ICON, 16, 16, 0);
if (!RegisterClassEx(&myWC)) {
if (!RegisterClass((LPWNDCLASS)&myWC.style))
return(0);
}
}
// load accelerators
myAccel = LoadAccelerators(hInstance, gAppName);
// initialize QuickTime Media Layer and QuickTime; alert the user and return 0 if unsuccessful
myErr = InitializeQTML(0L);
if (myErr != noErr) {
MessageBox(NULL, "QuickTime is not installed on this computer. Exiting.", gAppName, MB_OK | MB_APPLMODAL);
return(0);
}
myErr = EnterMovies();
if (myErr != noErr) {
MessageBox(NULL, "Could not initialize QuickTime. Exiting.", gAppName, MB_OK | MB_APPLMODAL);
return(0);
}
// get the application's resource file, if it exists
myLength = GetModuleFileName(NULL, myFileName, MAX_PATH); // NULL means: the current process
if (myLength != 0) {
NativePathNameToFSSpec(myFileName, &gAppFSSpec, kFullNativePath);
gAppResFile = FSpOpenResFile(&gAppFSSpec, fsRdWrPerm);
if (gAppResFile != kInvalidFileRefNum)
UseResFile(gAppResFile);
}
// do any application-specific initialization that must occur before the frame window is created
QTApp_Init(kInitAppPhase_BeforeCreateFrameWindow);
// create the main frame window
myWindowFrame = CreateWindow(gAppName, gAppName, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
hInstance,
NULL);
ghWnd = myWindowFrame;
// make sure we got a frame window
if (myWindowFrame == NULL)
return(0);
// show the window
ShowWindow(myWindowFrame, nCmdShow);
UpdateWindow(myWindowFrame);
// do any application-specific initialization that must occur after the frame window is created
QTApp_Init(kInitAppPhase_AfterCreateFrameWindow);
// get and process events until the user quits
while (GetMessage(&myMsg, NULL, 0, 0)) {
if (!TranslateMDISysAccel(ghWndMDIClient, &myMsg)) {
if (!TranslateAccelerator(myWindowFrame, myAccel, &myMsg)) {
TranslateMessage(&myMsg);
DispatchMessage(&myMsg);
}
}
}
// close the application's resource file, if it was previously opened
if (gAppResFile != kInvalidFileRefNum)
CloseResFile(gAppResFile);
// terminate the QuickTime Media Layer
ExitMovies();
TerminateQTML();
return(myMsg.wParam); // returns the value from PostQuitMessage
}
/* 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;
}
static Boolean SearchDirectory( UInt16 volID, UInt32 dirID, UInt8 * targetLang, OSType sig, UInt32 depth )
{
Str31 fileName;
UInt16 fileIndex = 1;
OSErr err = noErr;
CInfoPBRec catPb;
Boolean found = false;
struct LanguageDescriptor ** locaRSRC;
gLocaleResFile = 0; /* Set locale file to invalid number */
while( err == noErr ) {
catPb.dirInfo.ioCompletion = nil;
catPb.dirInfo.ioNamePtr = fileName;
catPb.dirInfo.ioVRefNum = volID;
catPb.dirInfo.ioFDirIndex = fileIndex++;
catPb.dirInfo.ioDrDirID = dirID;
err = PBGetCatInfoSync( &catPb );
// If I found a folder, then look inside. But only go to the specified depth
if( err == noErr) {
if( catPb.dirInfo.ioFlAttrib & (1<<4) ) { // Look in the folder, if I haven't exceeded the depth
if( depth ) {
if( SearchDirectory( volID, catPb.dirInfo.ioDrDirID, targetLang, sig, depth - 1 ) )
return true; /* A locale file was found, so exit */
else
continue; /* Nothing so far, so keep looking */
}
else {
continue;
}
}
else { // Check if its a locale file
if( catPb.hFileInfo.ioFlFndrInfo.fdType == 'LANG'
&& catPb.hFileInfo.ioFlFndrInfo.fdCreator == 'CARO' ) {
ASInt16 curLocaleFile;
/* Fix for 408144.
** Check for an open resource file. Skip already open files.
** If another Plugin has it open this will cause great confusion.
** Example is "WHA" and "WHA Library". "WHA Library" close the "WHA lang"
** file while looking for the "WHA Library lang" file.
*/
curLocaleFile = GetResRefNumFromFCB(volID, dirID, fileName);
if( curLocaleFile != -1 )
continue; /* continue on to the next file */
curLocaleFile = HOpenResFile( volID, dirID, fileName, fsCurPerm );
if( curLocaleFile == -1 ) /* Check for a valid file. If its bad, then */
continue; /* continue on to the next file */
locaRSRC = (struct LanguageDescriptor **) Get1Resource( 'LOCA', 2010 );
if( locaRSRC ) {
if( (*locaRSRC)->mSignature == sig ) { /* Check the client signature */
if( (*locaRSRC)->mLocale3Letters == *( UInt32 * )targetLang )
{
gLocaleResFile = curLocaleFile;
}
}
ReleaseResource( ( Handle )locaRSRC );
}
if( gLocaleResFile != curLocaleFile ) {
CloseResFile( curLocaleFile ); /* Release the locale file */
continue; /* Didn't find it, so try the next one */
}
else
return true; /* Got it, so exit */
}
}
}
}
return false; /* Found nothing */
}
static void AddFolderIcon(FSRef *fref, const char *folderName)
{
OSStatus err;
FSCatalogInfo fcat, icat;
FSRef bref, iref;
CFStringRef str;
CFURLRef url;
IconFamilyHandle family;
IconRef icon;
HFSUniStr255 fork;
Boolean r;
SInt16 resf;
char name[64];
UniChar iconName[5] = { 'I', 'c', 'o', 'n', '\r' };
strcpy(name, "folder_");
strcat(name, folderName);
str = CFStringCreateWithCString(kCFAllocatorDefault, name, CFStringGetSystemEncoding());
if (str)
{
url = CFBundleCopyResourceURL(CFBundleGetMainBundle(), str, CFSTR("icns"), nil);
if (url)
{
r = CFURLGetFSRef(url, &bref);
if (r)
{
err = RegisterIconRefFromFSRef('~9X~', 'TEMP', &bref, &icon);
if (err == noErr)
{
err = FSGetResourceForkName(&fork);
if (err == noErr)
{
err = FSCreateResourceFile(fref, 5, iconName, kFSCatInfoNone, nil, fork.length, fork.unicode, &iref, nil);
if (err == noErr)
{
err = FSOpenResourceFile(&iref, fork.length, fork.unicode, fsWrPerm, &resf);
if (err == noErr)
{
err = IconRefToIconFamily(icon, kSelectorAllAvailableData, &family);
if (err == noErr)
{
AddResource((Handle) family, 'icns', -16455, "\p");
WriteResource((Handle) family);
ReleaseResource((Handle) family);
err = FSGetCatalogInfo(&iref, kFSCatInfoFinderInfo, &icat, nil, nil, nil);
((FileInfo *) &icat.finderInfo)->finderFlags |= kIsInvisible;
((FileInfo *) &icat.finderInfo)->fileCreator = 'MACS';
((FileInfo *) &icat.finderInfo)->fileType = 'icon';
err = FSSetCatalogInfo(&iref, kFSCatInfoFinderInfo, &icat);
err = FSGetCatalogInfo(fref, kFSCatInfoFinderInfo, &fcat, nil, nil, nil);
((FolderInfo *) &fcat.finderInfo)->finderFlags |= kHasCustomIcon;
((FolderInfo *) &fcat.finderInfo)->finderFlags &= ~kHasBeenInited;
err = FSSetCatalogInfo(fref, kFSCatInfoFinderInfo, &fcat);
}
CloseResFile(resf);
}
}
}
/* 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;
}
void
InitLicTxt(void)
{
Rect destRect, viewRect;
FSSpec licFile;
long dirID, dataSize;
short vRefNum, dataRef, resRef;
unsigned char* cLicFName;
Str255 pLicFName;
OSErr err;
Handle text, stylHdl;
ERR_CHECK(GetCWD(&dirID, &vRefNum));
/* open and read license file */
HLock(gControls->cfg->licFileName);
if(**gControls->cfg->licFileName != nil)
{
cLicFName = CToPascal(*gControls->cfg->licFileName);
ERR_CHECK(FSMakeFSSpec(vRefNum, dirID, cLicFName, &licFile));
if (cLicFName)
DisposePtr((char*)cLicFName);
}
else /* assume default license filename from str rsrc */
{
GetResourcedString(pLicFName, rInstList, sLicenseFName);
ERR_CHECK(FSMakeFSSpec(vRefNum, dirID, pLicFName, &licFile));
}
HUnlock(gControls->cfg->licFileName);
/* read license text */
ERR_CHECK(FSpOpenDF( &licFile, fsRdPerm, &dataRef));
ERR_CHECK(GetEOF(dataRef, &dataSize));
if (dataSize > 0)
{
if (!(text = NewHandle(dataSize)))
{
ErrorHandler(eMem, nil);
return;
}
ERR_CHECK(FSRead(dataRef, &dataSize, *text));
}
else
text = nil;
ERR_CHECK(FSClose(dataRef));
/* get 'styl' if license is multistyled */
resRef = FSpOpenResFile( &licFile, fsRdPerm);
ERR_CHECK(ResError());
UseResFile(resRef);
stylHdl = RGetResource('styl', 128);
ERR_CHECK(ResError());
if(stylHdl)
DetachResource(stylHdl);
else
stylHdl = nil;
CloseResFile(resRef);
/* TE specific init */
HLock( (Handle) gControls->lw->licBox);
SetRect(&viewRect, (*(gControls->lw->licBox))->contrlRect.left,
(*(gControls->lw->licBox))->contrlRect.top,
(*(gControls->lw->licBox))->contrlRect.right,
(*(gControls->lw->licBox))->contrlRect.bottom);
HUnlock( (Handle) gControls->lw->licBox);
destRect.left = viewRect.left;
viewRect.right = (*(gControls->lw->scrollBar))->contrlRect.left;
destRect.right = viewRect.right;
destRect.top = viewRect.top;
destRect.bottom = viewRect.bottom * kNumLicScrns;
// gControls->lw->licTxt = (TEHandle) NewPtrClear(sizeof(TEPtr));
TextFont(applFont);
TextFace(normal);
TextSize(9);
HLock(text);
if (stylHdl)
{
gControls->lw->licTxt = TEStyleNew( &destRect, &viewRect );
TEStyleInsert( *text, dataSize, (StScrpRec ** )stylHdl,
gControls->lw->licTxt);
}
else
{
gControls->lw->licTxt = TENew( &destRect, &viewRect);
TEInsert( *text, dataSize, gControls->lw->licTxt);
}
HUnlock(text);
TextFont(systemFont);
TextSize(12);
TESetAlignment(teFlushDefault, gControls->lw->licTxt);
}
/*-----------------------------------------------------------------
GetIndexedFragmentOffsets
Get the offsets into the data fork of the indexed fragment,
by reading the 'cfrg' resoruce.
-----------------------------------------------------------------*/
OSErr GetIndexedFragmentOffsets(const FSSpec *fileSpec, UInt32 fragmentIndex,
UInt32 *outOffset, UInt32 *outLength, char **outFragmentName)
{
CFragResourceHandle cFragHandle;
short fileRefNum;
OSErr err = noErr;
fileRefNum = FSpOpenResFile(fileSpec, fsRdPerm);
err = ResError();
if (err != noErr) return err;
cFragHandle = (CFragResourceHandle)Get1Resource(kCFragResourceType, kCFragResourceID);
if (!cFragHandle)
{
err = resNotFound;
goto done;
}
err = cfragNoLibraryErr; /* in case of failure */
*outOffset = 0;
*outLength = 0;
*outFragmentName = NULL;
/* the CStrFromPStr mallocs, so might move memory */
HLock((Handle)cFragHandle);
/* Now look for the named fragment */
if ((**cFragHandle).memberCount > 0)
{
CFragResourceMemberPtr memberPtr;
UInt16 i;
for ( i = 0, memberPtr = &(**cFragHandle).firstMember;
i < (**cFragHandle).memberCount;
i ++, memberPtr = (CFragResourceMemberPtr)((char *)memberPtr + memberPtr->memberSize))
{
if (i == fragmentIndex)
{
char *fragmentStr;
CStrFromPStr(memberPtr->name, &fragmentStr);
if (!fragmentStr) /* test for allocation failure */
{
err = memFullErr;
break;
}
*outFragmentName = fragmentStr;
*outOffset = memberPtr->offset;
*outLength = memberPtr->length;
err = noErr;
break;
}
}
}
HUnlock((Handle)cFragHandle);
/* Resource handle will go away when the res fork is closed */
done:
CloseResFile(fileRefNum);
return err;
}
/* Read Type 1 data from the POST resources inside the LWFN file,
return a PFB buffer. This is somewhat convoluted because the FT2
PFB parser wants the ASCII header as one chunk, and the LWFN
chunks are often not organized that way, so we glue chunks
of the same type together. */
static FT_Error
read_lwfn( FT_Memory memory,
ResFileRefNum res,
FT_Byte** pfb_data,
FT_ULong* size )
{
FT_Error error = FT_Err_Ok;
ResID res_id;
unsigned char *buffer, *p, *size_p = NULL;
FT_ULong total_size = 0;
FT_ULong old_total_size = 0;
FT_ULong post_size, pfb_chunk_size;
Handle post_data;
char code, last_code;
UseResFile( res );
/* First pass: load all POST resources, and determine the size of */
/* the output buffer. */
res_id = 501;
last_code = -1;
for (;;)
{
post_data = Get1Resource( TTAG_POST, res_id++ );
if ( !post_data )
break; /* we are done */
code = (*post_data)[0];
if ( code != last_code )
{
if ( code == 5 )
total_size += 2; /* just the end code */
else
total_size += 6; /* code + 4 bytes chunk length */
}
total_size += (FT_ULong)GetHandleSize( post_data ) - 2;
last_code = code;
/* detect resource fork overflow */
if ( FT_MAC_RFORK_MAX_LEN < total_size )
{
error = FT_THROW( Array_Too_Large );
goto Error;
}
old_total_size = total_size;
}
if ( FT_ALLOC( buffer, (FT_Long)total_size ) )
goto Error;
/* Second pass: append all POST data to the buffer, add PFB fields. */
/* Glue all consecutive chunks of the same type together. */
p = buffer;
res_id = 501;
last_code = -1;
pfb_chunk_size = 0;
for (;;)
{
post_data = Get1Resource( TTAG_POST, res_id++ );
if ( !post_data )
break; /* we are done */
post_size = (FT_ULong)GetHandleSize( post_data ) - 2;
code = (*post_data)[0];
if ( code != last_code )
{
if ( last_code != -1 )
{
/* we are done adding a chunk, fill in the size field */
if ( size_p )
{
*size_p++ = (FT_Byte)( pfb_chunk_size & 0xFF );
*size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8 ) & 0xFF );
*size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
*size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
}
pfb_chunk_size = 0;
}
*p++ = 0x80;
if ( code == 5 )
*p++ = 0x03; /* the end */
else if ( code == 2 )
*p++ = 0x02; /* binary segment */
else
*p++ = 0x01; /* ASCII segment */
if ( code != 5 )
{
size_p = p; /* save for later */
p += 4; /* make space for size field */
}
}
ft_memcpy( p, *post_data + 2, post_size );
pfb_chunk_size += post_size;
p += post_size;
last_code = code;
}
*pfb_data = buffer;
*size = total_size;
Error:
CloseResFile( res );
return error;
}
LOCAL_FUNC
TT_Error TT_Open_Stream( const String* filepathname,
TT_Stream* stream )
{
TT_Error error;
Int file;
PStream_Rec stream_rec;
TFileMap* map;
int size, err = 0;
short vRefNum, res = -1;
Str255 FontName;
char *cp, *p, *fname, *sep;
Str63 myName;
long dirID;
if ( ALLOC( *stream, sizeof ( TStream_Rec ) ) )
return error;
map = Allocate_Map();
if ( !map )
{
error = TT_Err_Out_Of_Memory;
goto Memory_Fail;
}
stream_rec = STREAM2REC( *stream );
/* Find the dirID of the Fonts folder in the current System folder */
if (FindFolder(kOnSystemDisk, kFontsFolderType, kDontCreateFolder, &vRefNum, &dirID))
goto File_Fail;
/* Break the name apart */
fname = mystrdup(filepathname); /* Make a copy so we can muck with it */
sep = ":/"; /* Things that can seperate file path componants */
strtok(fname, sep); /* Skip over "fonts:" */
if ((p = strtok(NULL, sep)) == NULL) /* Get filename */
goto File_Fail;
strcpy(myName + 1, p); /* Make this a Pascal string (Yuck!) */
myName[0] = strlen(p);
if ((p = strtok(NULL, sep)) == NULL) /* Get res name */
goto File_Fail;
strcpy(FontName+1, p); /* Make this a Pascal string (Yuck!) */
FontName[0] = strlen(p);
FREE( fname );
if ((cp = strchr(FontName, '.')) != NULL) /* Strip off ".ttf" , if any */
*cp = 0;
/* Read the font into a buffer */
if ((map->resid = HOpenResFile(vRefNum, dirID, myName, fsRdPerm)) == -1)
goto File_Fail;
if ((map->handle = Get1NamedResource('sfnt', FontName)) == NULL)
goto Map_Fail;
HLock(map->handle);
map->base = *map->handle;
map->offset = 0;
map->size = GetResourceSizeOnDisk(map->handle);
if ( map->base == NULL )
goto Lock_Fail;
stream_rec->map = map;
stream_rec->pos = 0;
#ifndef TT_CONFIG_OPTION_THREAD_SAFE
CUR_Stream = stream_rec;
#endif
return TT_Err_Ok;
Lock_Fail:
ReleaseResource(map->handle);
Map_Fail:
CloseResFile(map->resid);
File_Fail:
error = TT_Err_Could_Not_Open_File;
FREE( map );
Memory_Fail:
FREE( *stream );
FREE( fname );
return error;
}
/* parse and summarize FOND resource information */
static fond_table * parse_fond(FSSpec *spec)
{
OSErr result = noErr;
FSRef specref;
SInt16 ref;
Handle fond = NULL;
unsigned char *res;
fond_table *table = NULL;
int i,j, count, n, start;
/* FSpOpenResFile will fail for data fork resource (.dfont) files.
FSOpenResourceFile can open either, but cannot handle broken resource
maps, as often occurs in font files (the suitcase version of Arial,
for example) Thus, we try one, and then the other. */
result = FSpMakeFSRef(spec,&specref);
#ifdef __CARBON__
if (result == noErr)
result = FSOpenResourceFile(&specref, 0, NULL, fsRdPerm, &ref);
#else
result = bdNamErr; /* simulate failure of the carbon routine above */
#endif
if (result != noErr) {
ref = FSpOpenResFile(spec, fsRdPerm);
result = ResError();
}
if (result != noErr || ref <= 0) {
char path[256];
convertSpecToPath(spec, path, 256);
dlprintf2("unable to open resource file '%s' for font enumeration (error %d)\n",
path, result);
goto fin;
}
/* we've opened the font file, now loop over the FOND resource(s)
and construct a table of the font references */
start = 0; /* number of entries so far */
UseResFile(ref);
count = Count1Resources('FOND');
for (i = 0; i < count; i++) {
fond = Get1IndResource('FOND', i+1);
if (fond == NULL) {
result = ResError();
goto fin;
}
/* The FOND resource structure corresponds to the FamRec and AsscEntry
data structures documented in the FontManager reference. However,
access to these types is deprecated in Carbon. We therefore access the
data by direct offset in the hope that the resource format will not change
even if api access to the in-memory versions goes away. */
HLock(fond);
res = *fond + 52; /* offset to association table */
n = get_int16(res) + 1; res += 2;
table = fond_table_grow(table, n);
for (j = start; j < start + n; j++ ) {
table->refs[j].size = get_int16(res); res += 2;
table->refs[j].style = get_int16(res); res += 2;
table->refs[j].id = get_int16(res); res += 2;
}
start += n;
HUnlock(fond);
}
fin:
CloseResFile(ref);
return table;
}
