uint32_t hsStream::GetSizeLeft()
{
uint32_t ret = 0;
if (GetPosition() > GetEOF())
{
hsThrow("Position is beyond EOF");
}
else
{
ret = GetEOF() - GetPosition();
}
return ret;
}
char * ReadDataFile (long * pBufferSize, FSSpec * pfsspecData)
{
NavReplyRecord replyNav;
NavTypeListHandle hTypeList = (NavTypeListHandle) NewHandleClear (sizeof (NavTypeList) + sizeof (OSType) * 1);
AEKeyword theKeyword;
DescType actualType;
Size actualSize;
OSStatus err = noErr;
short fileRef;
char * pFileBuffer;
HLock ((Handle) hTypeList);
(**hTypeList).osTypeCount = 2;
(**hTypeList).osType[0] = 'TEXT';
(**hTypeList).osType[1] = '????';
// select sprite file
err = NavChooseFile (NULL, &replyNav, NULL, NULL, NULL, NULL, hTypeList, NULL);
if ((err == noErr) && (replyNav.validRecord))
err = AEGetNthPtr (&(replyNav.selection), 1, typeFSS, &theKeyword, &actualType,
pfsspecData, sizeof (FSSpec), &actualSize);
NavDisposeReply (&replyNav);
if (err != noErr)
return false;
FSpOpenDF(pfsspecData, fsRdPerm, &fileRef);
GetEOF(fileRef, pBufferSize);
pFileBuffer = (char *) NewPtrClear (*pBufferSize);
FSRead (fileRef, pBufferSize, pFileBuffer);
FSClose (fileRef);
return pFileBuffer;
}
unsigned int
XMLMacCarbonFile::size()
{
OSErr err = noErr;
unsigned int len = 0;
if (!mFileValid)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetSize);
if (gHasHFSPlusAPIs)
{
SInt64 bigLen = 0;
err = FSGetForkSize(mFileRefNum, &bigLen);
if (err == noErr)
len = bigLen;
}
else
{
long longLen;
err = GetEOF(mFileRefNum, &longLen);
if (err == noErr)
len = longLen;
}
if (err != noErr)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetSize);
return len;
}
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
SInt16 ref = *((SInt16 *) opaque);
SInt32 eofPos;
BAIL_IF_MACRO(oserr(GetEOF(ref, &eofPos)) != noErr, NULL, -1);
return((PHYSFS_sint64) eofPos);
} /* __PHYSFS_platformFileLength */
/* convert icns(icons for MacOS X) to IPIcon */
OSErr XIconToIPIcon(const FSSpec *theFile,IPIconRec *ipIcon)
{
OSErr err;
IconFamilyHandle theIconFamily;
short refNum;
long count;
if (isIconServicesAvailable)
{
/* open icns file */
err=FSpOpenDF(theFile,fsRdPerm,&refNum);
if (err!=noErr) return err;
err=GetEOF(refNum,&count);
if (err!=noErr)
{
FSClose(refNum);
return err;
}
theIconFamily=(IconFamilyHandle)NewHandle(count);
HLock((Handle)theIconFamily);
err=FSRead(refNum,&count,*theIconFamily);
HUnlock((Handle)theIconFamily);
err=FSClose(refNum);
/* convert IconFamily to IPIcon */
err=IconFamilyToIPIcon(theIconFamily,ipIcon);
DisposeHandle((Handle)theIconFamily);
return err;
}
else
return -1;
}
// RAB BetterTelnet 2.0b5
void parseNewMacros(NewMacroInfo *macrost, short fileRef)
{
Handle macroHandle;
Ptr macroPtr, pos;
long macroLength, count, len;
OSErr fileErr;
short i, flag;
fileErr = GetEOF(fileRef, ¯oLength);
macroLength -= 2; // compensate for !CR
macroHandle = myNewHandle(macroLength);
if (!macroHandle) { // memory error?
disposemacros(macrost);
setupNewMacros(macrost); // this better work, or we crash hard
return;
}
HLock(macroHandle);
macroPtr = *macroHandle;
count = macroLength;
FSRead(fileRef, &count, macroPtr);
parseNewMacros2(macrost, macroHandle);
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
long fpos, size;
if (GetEOF((short) fd, &size) != noErr)
return EOF;
(void) GetFPos((short) fd, &fpos);
switch (whence) {
case SEEK_CUR:
if (off + fpos > size)
SetEOF((short) fd, off + fpos);
if (SetFPos((short) fd, fsFromMark, off) != noErr)
return EOF;
break;
case SEEK_END:
if (off > 0)
SetEOF((short) fd, off + size);
if (SetFPos((short) fd, fsFromStart, off + size) != noErr)
return EOF;
break;
case SEEK_SET:
if (off > size)
SetEOF((short) fd, off);
if (SetFPos((short) fd, fsFromStart, off) != noErr)
return EOF;
break;
}
return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF);
}
long file_seek(FILEH handle, long pointer, int method) {
SInt32 pos;
SInt32 setp;
setp = pointer;
switch(method) {
case FSEEK_SET:
break;
case FSEEK_CUR:
if (GetFPos(handle, &pos) != noErr) {
return(-1);
}
setp += pos;
break;
case FSEEK_END:
if (GetEOF(handle, &pos) != noErr) {
return(-1);
}
setp += pos;
break;
default:
return(-1);
}
SetFPos(handle, fsFromStart, setp);
if (GetFPos(handle, &pos) != noErr) {
return(-1);
}
return((long)pos);
}
int __PHYSFS_platformEOF(void *opaque)
{
SInt16 ref = *((SInt16 *) opaque);
SInt32 eofPos, curPos;
BAIL_IF_MACRO(oserr(GetEOF(ref, &eofPos)) != noErr, NULL, 1);
BAIL_IF_MACRO(oserr(GetFPos(ref, &curPos)) != noErr, NULL, 1);
return(curPos >= eofPos);
} /* __PHYSFS_platformEOF */
PicHandle OpenPICTFile(
short vRefNum,
Str255 fName)
{
short fRefNum;
OSErr err;
long curEOF;
PicHandle myPic;
long count;
Ptr buffer;
/* open PICT file */
err = FSOpen(fName, vRefNum, &fRefNum);
if (err != 0) {
/*printf("Error - cannot open file\n"); */
exit(-1);
}
/* get size of file */
err = GetEOF(fRefNum, &curEOF);
if (err != 0) {
/*printf("Error - cannot get EOF\n"); */
exit(-2);
}
/* move the file mark to 512 */
err = SetFPos(fRefNum, SEEK_SET, 512L);
if (err != 0) {
/*printf("Error - cannot seek 512\n"); */
exit(-3);
}
/* size of data to read */
count = curEOF - 512;
/* create the PicHandle */
myPic = (PicHandle)NewHandle(count);
HLock((Handle)myPic);
/* read the PICT info */
buffer = (Ptr)(*myPic);
err = FSRead(fRefNum, &count, buffer);
if (err != 0) {
/*printf("Error - cannot read\n");*/
exit(-4);
}
HUnlock((Handle)myPic);
/* release the file */
err = FSClose(fRefNum);
if (err != 0) {
/*printf("Error - cannot close file \n"); */
exit(-5);
}
return (myPic);
}
static toff_t
_tiffSizeProc(thandle_t fd)
{
long size;
if (GetEOF((short) fd, &size) != noErr) {
TIFFError("_tiffSizeProc", "%s: Cannot get file size");
return (-1L);
}
return ((toff_t) size);
}
UINT file_getsize(FILEH handle) {
SInt32 pos;
if (GetEOF(handle, &pos) == noErr) {
return((UINT)pos);
}
else {
return(0);
}
}
static long
ResourceForkSize(FSSpec* spec)
{
long len;
short refNum;
OSErr e;
e = FSpOpenRF( spec, fsRdPerm, &refNum ); /* I.M. Files 2-155 */
if ( e == noErr )
{
e = GetEOF( refNum, &len );
FSClose( refNum );
}
return ( e == noErr ) ? len : 0;
}
INT64 NCSFileSeek(int hFile,
INT64 nOffset,
int origin)
{
#ifdef WIN32
return((INT64)_lseeki64(hFile, (__int64)nOffset, origin));
#elif defined MACINTOSH
long fpos, size;
if (GetEOF((short) hFile, &size) != noErr)
return EOF;
(void) GetFPos((short) hFile, &fpos);
switch (origin) {
case SEEK_CUR:
if (nOffset + fpos > size)
SetEOF((short) hFile, nOffset + fpos);
if (SetFPos((short) hFile, fsFromMark, nOffset) != noErr)
return EOF;
break;
case SEEK_END:
if (nOffset > 0)
SetEOF((short) hFile, nOffset + size);
if (SetFPos((short) hFile, fsFromStart, nOffset + size) != noErr)
return EOF;
break;
case SEEK_SET:
if (nOffset > size)
SetEOF((short) hFile, nOffset);
if (SetFPos((short) hFile, fsFromStart, nOffset) != noErr)
return EOF;
break;
}
return (INT64)(GetFPos((short) hFile, &fpos) == noErr ? fpos : EOF);
#else /* WIN32 */
#error: NCSFileSeek()
#endif /* WIN32 */
}
/*
** Get current file position
*/
INT64 NCSFileTell(int hFile)
{
#ifdef WIN32
return((INT64)_telli64(hFile));
#elif defined MACINTOSH
/* Simon's code
UINT32 fileLocation;
fgetpos(hFile,(unsigned long *)&fileLocation);
return((UINT64)fileLocation);
*/
long fpos, size;
if (GetEOF((short) hFile, &size) != noErr)
return EOF;
return (INT64)size;
//return (INT64) GetFPos((short) hFile, &fpos);
#else /* WIN32 */
#error NCSFileTell()
#endif /* WIN32 */
}
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);
}
/*
* The caller is responsible for opening the file, passing its refNum,
* and closing it after we're done
*/
void scanOMF(int fd, char *fname)
{
OMFhead header;
longword off = 0l;
PositionRecGS p;
int kind;
int i;
p.pCount = 2;
p.refNum = fd;
GetEOF(&p);
while (off < p.position) {
lseek(fd, off, SEEK_SET);
read(fd,&header,sizeof(header));
/* First time through, check validity of OMF header [v1.1] */
if (off == 0 && notOMF(&header)) {
printf("Note: %s is not a recognized OMF file\n", fname);
return;
}
lseek(fd, off+header.DISPNAME+10, SEEK_SET);
if (header.LABLEN == 0) {
read(fd, name, 1);
read(fd, name+1, name[0]);
} else {
name[0] = header.LABLEN;
read(fd, name+1, header.LABLEN);
}
printf("%s",fname);
i = strlen(fname);
while (i++ < 20) putchar(' ');
kind = header.KIND & 0x1F;
switch (kind) {
case 0x00:
if (decimal_output)
printf(" %s %8ld ", segTypes[kind],header.LENGTH);
else
printf(" %s 0x%06lX ", segTypes[kind],header.LENGTH);
/* Check code segment for stack allocation [v1.1] */
/* Position to beginning of data */
lseek(fd, off+header.DISPDATA, SEEK_SET);
/* Check the code */
checkCodeStack(fd);
break;
case 0x01:
case 0x02:
case 0x04:
case 0x08:
case 0x10:
case 0x12:
if (decimal_output)
printf(" %s %8ld ", segTypes[kind],header.LENGTH);
else
printf(" %s 0x%06lX ", segTypes[kind],header.LENGTH);
break;
default:
printf(" unknown (0x%02X) ", kind);
}
prntAscii(name+1,name[0]);
putchar('\n');
/* In OMF version 1, the first field is a block count */
if (header.VERSION == 1)
off += (header.BYTECNT * 512);
else
off += header.BYTECNT;
/* Check for unusual case that causes infinite loop [v1.1] */
if (header.BYTECNT == 0) break;
}
}
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);
}
