OSErr choose_new_file(
short *file_handle,
short *reference_number,
char *file_name,
char *prompt,
long creator,
long file_type)
{
Point location;
SFReply reply;
OSErr error;
SetPt(&location, 40, 60);
SFPutFile(location, prompt, file_name, (DlgHookProcPtr) NULL, &reply);
if (reply.good)
{
error= Create(reply.fName, reply.vRefNum, creator, file_type);
if (error==dupFNErr||error==noErr)
{
strncpy(file_name, reply.fName, *reply.fName+1);
*reference_number= reply.vRefNum;
error= FSOpen(reply.fName, reply.vRefNum, file_handle);
}
}
else
{
error= userCanceledErr;
}
return error;
}
static void SaveToPICT (SFReply *reply)
{
Rect MyPicFrame ;
CQDProcs MyPicProcs,*SavePtr ;
OSErr error ;
long LongZero, LongCount ;
short Counter ;
CGrafPtr theCGrafPort;
WindowPtr theWindow;
OpenCPicParams myOpenCPicParams;
/* get my window */
theWindow = myWindow.theWindow;
theCGrafPort = (CGrafPtr) theWindow;
error = FSOpen(reply->fName, reply->vRefNum, &FileSys_RefNR ) ;
SetStdCProcs ( &MyPicProcs ) ;
SavePtr = (CQDProcs *) theWindow->grafProcs;
theWindow->grafProcs = (QDProcs *) (&MyPicProcs) ;
MyPicProcs.putPicProc = NewQDPutPicProc(MyPutPicData) ;
LongZero = 0 ;
LongCount = 4 ;
PicCounter = sizeof(Picture) ;
for (Counter=1 ; Counter <= 128+sizeof(Picture) ; Counter++ )
error = FSWrite(FileSys_RefNR, &LongCount, &LongZero );
error = SetFPos(FileSys_RefNR, fsFromStart, 512+sizeof(Picture)) ;
SetPort((GrafPtr)(theWindow));
MyPicFrame = ((GrafPtr)(theWindow))->portRect;
MyPicFrame.right = MyPicFrame.right-16;
MyPicFrame.bottom = MyPicFrame.bottom-16;
MyPicHand = NULL ;
myOpenCPicParams.srcRect = MyPicFrame;
myOpenCPicParams.hRes = cHRes;
myOpenCPicParams.vRes = cVRes;
myOpenCPicParams.version = -2;
myOpenCPicParams.reserved1 = 0;
myOpenCPicParams.reserved2 = 0;
MyPicHand = OpenCPicture ( &myOpenCPicParams );
ClipRect(&MyPicFrame);
/* draw picture */
RefreshCommand();
ClosePicture() ;
/* close File */
error = SetFPos(FileSys_RefNR, fsFromStart, 512) ;
LongCount = sizeof(Picture) ;
error = FSWrite(FileSys_RefNR, &LongCount, (void *) (*MyPicHand) );
error = FSClose(FileSys_RefNR) ;
KillPicture(MyPicHand);
theWindow->grafProcs = (QDProcs *) SavePtr ;
return;
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
Str255 pname;
FInfo finfo;
short fref;
OSErr err;
strcpy((char*) pname, name);
CtoPstr((char*) pname);
switch (_TIFFgetMode(mode, module)) {
default:
return ((TIFF*) 0);
case O_RDWR | O_CREAT | O_TRUNC:
if (GetFInfo(pname, 0, &finfo) == noErr)
FSDelete(pname, 0);
/* fall through */
case O_RDWR | O_CREAT:
if ((err = GetFInfo(pname, 0, &finfo)) == fnfErr) {
if (Create(pname, 0, ' ', 'TIFF') != noErr)
goto badCreate;
if (FSOpen(pname, 0, &fref) != noErr)
goto badOpen;
} else if (err == noErr) {
if (FSOpen(pname, 0, &fref) != noErr)
goto badOpen;
} else
goto badOpen;
break;
case O_RDONLY:
case O_RDWR:
if (FSOpen(pname, 0, &fref) != noErr)
goto badOpen;
break;
}
return (TIFFFdOpen((int) fref, name, mode));
badCreate:
TIFFError(module, "%s: Cannot create", name);
return ((TIFF*) 0);
badOpen:
TIFFError(module, "%s: Cannot open", name);
return ((TIFF*) 0);
}
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);
}
P3(PUBLIC pascal trap, LONGINT, PutScrap, LONGINT, len, ResType, rest, Ptr, p)
{
OSErr retval;
LONGINT l, swappedlen;
INTEGER f;
LONGINT *lp;
if (Cx(ScrapState) < 0) {
retval = ZeroScrap();
if (retval != noErr)
/*-->*/ return(retval);
}
#if defined(X) || defined(NEXTSTEP) || defined (SDL)
PutScrapX(rest, len, (char *) p, CW (ScrapCount));
#endif /* defined(X) */
if (Cx(ScrapState) == 0) {
retval = FSOpen(MR(ScrapName), CW (BootDrive), &f);
if (retval != noErr)
/*-->*/ return(retval);
SetFPos(f, fsFromStart, (LONGINT)Cx(ScrapSize));
l = 4;
rest = CL(rest);
FSWriteAll(f, &l, (Ptr) &rest);
l = 4;
swappedlen = CL(len);
FSWriteAll(f, &l, (Ptr) &swappedlen);
l = len = (len + 1) & -2L;
FSWriteAll(f, &len, p);
FSClose(f);
} else {
SetHandleSize(MR(ScrapHandle), (Size)Cx(ScrapSize) + 8);
if (MemErr != noErr)
/*-->*/ return CW(MemErr);
/* alignment stuff */
lp = (LONGINT *)((char *)STARH(MR(ScrapHandle)) + Cx(ScrapSize));
*lp++ = CL(rest);
*lp++ = CL(len);
len = (len + 1) & -2L;
PtrAndHand(p, MR(ScrapHandle), (Size)len);
}
ScrapSize = CL(CL(ScrapSize) + 8 + len);
return noErr;
}
OSErr choose_and_open_file(
short *file_handle,
short *reference_number,
char *file_name,
long spec1,
long spec2,
long spec3,
long spec4)
{
Point location;
SFTypeList filetypes;
SFReply reply;
OSErr error;
short count;
filetypes[0]= spec1, filetypes[1]= spec2, filetypes[2]= spec3, filetypes[3]= spec4;
for (count=0;count<4;++count)
{
if (!filetypes[count])
{
break;
}
}
SetPt(&location, 40, 60);
SFGetFile(location, (char *) NULL, NULL, count, filetypes, NULL, &reply);
if (reply.good)
{
strncpy(file_name, reply.fName, reply.fName[0]+1);
*reference_number= reply.vRefNum;
error= FSOpen(reply.fName, reply.vRefNum, file_handle);
}
else
{
error= userCanceledErr;
}
return error;
}
/////////////////////////////////////
// Name: CmdExecFile
// Purpose: execute commands from file
// Output: stuff executed
// Return: TRUE if success
/////////////////////////////////////
s32 CmdExecFile(const tCHAR *filename)
{
hFILE fp = FSOpen(filename, L"rt");
if(!fp)
return FALSE;
tCHAR buff[MAXCHARBUFF];
while(!FSEOF(fp))
{
ParserReadStringFile(fp, buff, MAXCHARBUFF, 0, '\n');
if(buff[0] != 0)
CmdCallStr(buff);
}
//in case we had 'wait' commands in the file, which we should not
g_postWait = FALSE;
return TRUE;
}
NCSError NCSFileOpen(const NCSTChar *szFilename, int iFlags, NCS_FILE_HANDLE *phFile)
{
#ifdef WIN32
DWORD dwMode = GENERIC_READ;
DWORD dwCreate = OPEN_EXISTING;
if(iFlags & NCS_FILE_READ) dwMode = GENERIC_READ;
if(iFlags & NCS_FILE_READ_WRITE) dwMode = GENERIC_READ|GENERIC_WRITE;
if(iFlags & NCS_FILE_CREATE) dwCreate = CREATE_ALWAYS;
if(iFlags & NCS_FILE_CREATE_UNIQUE) dwCreate = CREATE_NEW;
if(iFlags & NCS_FILE_APPEND) dwCreate = OPEN_ALWAYS;
*phFile = CreateFile(szFilename, // file name
dwMode, // Generic read mode
FILE_SHARE_READ, // Let anyone access and share the file
NULL, // No security info (so can't be inherited by child process)
dwCreate, // File must exist to be opened
FILE_FLAG_RANDOM_ACCESS, // Going to be doing lots of random access
NULL); // And no template file for attributes
if( *phFile == INVALID_HANDLE_VALUE ) {
return( NCS_FILE_OPEN_FAILED );
} else {
return( NCS_SUCCESS );
}
#elif defined MACINTOSH
#if __POWERPC__
int i,length, result;
Str255 pascalString;
FSSpec fileSpec;
// We have a C string, we need a PASCAL string.
length = strlen(szFilename) + 1;
for(i = 1; i < length; ++i)
pascalString[i] = szFilename[i - 1];
pascalString[0] = strlen(szFilename);
// Create a File Specification Record, then create a File
result = FSMakeFSSpec(0,0,pascalString,&fileSpec); // return is meaningless, since the only possible error doesn't effect processing in this case
switch(result) {
case noErr:
// we could dRes pFile here, but we are the only user
result =FSpOpenDF(&fileSpec, fsRdPerm, (short *)phFile);
if(result) return NCS_FILE_OPEN_FAILED;
else return NCS_SUCCESS;
break;
default:
return NCS_SUCCESS;
break;
}
#else /* __POWERPC__ */
int i,length, result;
Str255 pascalString;
// We have a C string, we need a PASCAL string.
length = strlen(szFilename) + 1;
for(i = 1; i < length; ++i)
pascalString[i] = szFilename[i - 1];
pascalString[0] = strlen(szFilename);
result =FSOpen(pascalString, 0, (short *)phFile);
if(result) return TRUE;
else return FALSE;
#endif /* __POWERPC__ */
#elif defined PALM
NCS_FILE_HANDLE hFile;
Err eErr;
UInt32 nMode = 0;
if(hFile = (NCS_FILE_HANDLE)NCSMalloc(sizeof(NCS_FILE_HANDLE_STRUCT), TRUE)) {
hFile->dbID = DmFindDatabase(0, szFilename);
if(hFile->dbID) {
Char nameP[dmDBNameLength];
UInt16 attributes;
UInt16 version;
UInt32 crDate;
UInt32 modDate;
UInt32 bckUpDate;
UInt32 modNum;
LocalID appInfoID;
LocalID sortInfoID;
UInt32 type;
UInt32 creator;
DmDatabaseInfo(0, hFile->dbID, nameP,
&attributes,
&version,
&crDate,
&modDate,
&bckUpDate,
&modNum,
&appInfoID,
&sortInfoID,
&type,
&creator);
if(creator == NCS_PALM_CREATOR_ID) {
if(hFile->dbRef = DmOpenDatabase(0, hFile->dbID, dmModeReadOnly|dmModeShowSecret)) {
UInt32 nRecords;
UInt32 nTotalBytes;
UInt32 nDataBytes;
eErr = DmDatabaseSize(0, hFile->dbID, &nRecords, &nTotalBytes, &nDataBytes);
if(eErr == errNone) {
MemHandle hRecord;
hFile->nRecords = nRecords;
hFile->nDBSize = nDataBytes;
#ifdef NOTDEF
if(hRecord = DmGetRecord(hFile->dbRef, 0)) {
MemPtr pData;
if(pData = MemHandleLock(hRecord)) {
hFile->nRecordSize = ((UINT16*)pData)[0];
MemHandleUnlock(hRecord);
}
DmReleaseRecord(hFile->dbRef, 0, false);
}
#endif
*phFile = hFile;
return(NCS_SUCCESS);
}
DmCloseDatabase(hFile->dbRef);
return(NCSPalmGetNCSError(eErr));
}
}
}
} else {
return(NCS_COULDNT_ALLOC_MEMORY);
}
/*
if(iFlags & NCS_FILE_READ) nMode = fileModeReadOnly|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_READ_WRITE) nMode = fileModeUpdate|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_CREATE) nMode = fileModeReadWrite|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_CREATE_UNIQUE) nMode = fileModeReadWrite|fileModeDontOverwrite|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_APPEND) nMode = fileModeAppend|fileModeAnyTypeCreator;
*phFile = FileOpen(0, (char*)szFilename, 0, 0, nMode, &eErr);
return(NCSPalmGetNCSError(eErr));
*/
#elif defined(POSIX)
int flags = O_RDONLY;
if(iFlags & NCS_FILE_READ) flags = O_RDONLY;
if(iFlags & NCS_FILE_READ_WRITE) flags = O_RDWR;
if(iFlags & NCS_FILE_CREATE) flags |= O_CREAT;
if(iFlags & NCS_FILE_CREATE_UNIQUE) flags |= O_CREAT|O_EXCL;
if(iFlags & NCS_FILE_APPEND) flags |= O_APPEND;
#if defined SOLARIS || (defined(HPUX) && !defined(__LP64__))
// Enable 64bit!
flags |= O_LARGEFILE;
#endif
#ifdef HPUX
*phFile = open64((const char*)CHAR_STRING(szFilename), (int)flags);
#ifdef NOTDEF
if (*phFile < 0) {
fprintf(stderr, "Error opening file : %ld\n", errno);
if (errno == EOVERFLOW) {
fprintf(stderr, "The named file is a regular file and the size "
"of the file cannot be represented correctly in an object of "
"size off_t.");
}
}
#endif
#else
*phFile = open((const char*)CHAR_STRING(szFilename), (int)flags, S_IRUSR|S_IWUSR);
#endif
if(*phFile != -1) {
return(NCS_SUCCESS);
} else {
return(NCS_FILE_OPEN_FAILED);
}
#else /* SOLARIS||IRIX */
#error ERROR EcwFileCreate() routine is not defined for this platform
#endif /* WIN32 */
}
P3(PUBLIC pascal trap, LONGINT, GetScrap, Handle, h, ResType, rest,
LONGINT *, off)
{
OSErr retval;
LONGINT l = 0, incr, s, ltoread, restlen[2];
unsigned char *p;
int found;
INTEGER f;
Handle temph;
#if !defined (LETGCCWAIL)
s = 0;
#endif /* LETGCCWAIL */
if (h)
temph = 0;
else {
temph = NewHandle((Size) 0);
h = temph;
}
#if defined(X) || defined(NEXTSTEP) || defined (SDL)
s = GetScrapX(rest, (char **) h);
if (s >= 0) {
*off = 0; /* ack... could mess people up */
/*-->*/ RETURN(s);
}
#endif /* defined(X) */
if (Cx(ScrapState) < 0) {
retval = ZeroScrap();
if (retval != noErr)
/*-->*/ RETURN(retval);
}
if (ScrapState == 0) {
retval = FSOpen(MR(ScrapName), CW (BootDrive), &f);
if (retval != noErr)
/*-->*/ RETURN(retval);
found = FALSE;
while (l < Cx(ScrapSize) && !found) {
ltoread = 8;
FSReadAll(f, <oread, (Ptr) restlen);
s = CL(restlen[1]);
if (rest == CL(restlen[0]))
found = TRUE;
else {
incr = (8 + s + 1) & ~1L;
l += incr;
SetFPos(f, fsFromMark, incr);
}
}
if (l >= Cx(ScrapSize)) {
FSClose(f);
/*-->*/ RETURN(noTypeErr);
}
ReallocHandle(h, s);
if (MemErr != noErr)
/*-->*/ RETURN(CW(MemErr));
HLock(h);
ltoread = s;
FSReadAll(f, <oread, STARH(h));
HUnlock(h);
FSClose(f);
} else {
HLock(MR(ScrapHandle));
p = MR(*(unsigned char **)MR(ScrapHandle));
#if 1 || !defined(QUADALIGN)
while (l < Cx(ScrapSize) && rest != CL(*(LONGINT *)p))
{
s = CL (*((LONGINT *) p + 1));
incr = (8 + s + 1) & ~1L;
l += incr;
p += incr;
}
if (l >= Cx(ScrapSize))
{
HUnlock(MR(ScrapHandle));
/*-->*/ RETURN(noTypeErr);
}
s = CL (*((LONGINT *)p + 1));
#else /* QUADALIGN */
while (l < Cx(ScrapSize) && rest != SNAGLONG(p)) {
incr = 8 + ((s = SNAGLONG(p + sizeof(LONGINT))) + 1) & -2L;
l += incr;
p += incr;
}
if (l >= Cx(ScrapSize))
{
HUnlock(MR(ScrapHandle));
/*-->*/ RETURN(noTypeErr);
}
s = *((LONGINT *)p + 1);
#endif /* QUADALIGN */
PtrToXHand((Ptr) (p+8), h, s);
HUnlock(MR(ScrapHandle));
}
*off = CL(l+8);
RETURN(s);
}
A1(PRIVATE, OSErr, cropen, INTEGER *, fp)
{
OSErr retval;
retval = FSOpen(MR(ScrapName), CW (BootDrive), fp);
if (retval == fnfErr) {
retval = Create(MR(ScrapName), CW (BootDrive), TICK("MACS"), TICK("CLIP"));
if (retval != noErr)
return(retval);
return(FSOpen(MR(ScrapName), CW (BootDrive), fp));
}
return(retval);
}
P0(PUBLIC pascal trap, LONGINT, LoadScrap)
{
OSErr retval;
INTEGER f;
LONGINT l = Cx(ScrapSize);
if (ScrapState == 0) {
retval = FSOpen(MR(ScrapName), CW (BootDrive), &f);
if (retval != noErr)
return(retval);
HUnlock(MR(ScrapHandle));
ReallocHandle(MR(ScrapHandle), (Size)Cx(ScrapSize));
if (MemErr != noErr)
/*-->*/ return Cx(MemErr);
HLock(MR(ScrapHandle));
retval = FSReadAll(f, &l, STARH(MR(ScrapHandle)));
HUnlock(MR(ScrapHandle));
if (retval != noErr)
return(retval);
SetEOF(f, (LONGINT) 0);
FSClose(f);
ScrapState = CWC (1);
}
return(Cx(ScrapState) > 0 ? noErr : noScrapErr);
}
