/****************************************************************************** * * NSSDC/CDF CDFedit, part 0 (main). * * Version 1.3b, 16-Nov-97, Hughes STX. * * Modification history: * * V1.0 25-Jan-94, J Love Original version. * V1.0a 4-Feb-94, J Love DEC Alpha/OpenVMS port. * V1.1 15-Dec-94, J Love CDF V2.5. * V1.1a 10-Jan-95, J Love Uppercase file extensions on the Macintosh. * V1.1b 23-Jan-95, J Love IRIX 6.x (64-bit). * V1.1c 28-Feb-95, J Love Pass `char' as `int'. * V1.2 11-Apr-95, J Love POSIX. * V1.2a 18-Apr-95, J Love More POSIX. * V1.2b 6-Sep-95, J Love CDFexport-related changes. FSI key * definitions. * V1.2c 28-Sep-95, J Love Macintosh dialog filtering. Outline default * button. * V1.3 22-Aug-96, J Love CDF V2.6. * V1.3a 21-Feb-97, J Love Removed RICE. * V1.4b 16-Nov-97, J Love Windows NT/Visual C++. * V1.5 11-Jul-05, M Liu Added MingW port for PC. * V1.6 03-May-06, M Liu Added checksum option for the files. * V1.7 13-Oct-06, M Liu Changed to allow upper and lower case CDF * name to be used on win32. * ******************************************************************************/ #define CDFEDIT #include "cdfedit.h" #if defined(vms) || defined(unix) || defined(posixSHELL) #define BROWSEaware 1 #else #define BROWSEaware 0 #endif /****************************************************************************** * Increased stack size and overlay buffer for Borland C on IBM PC. ******************************************************************************/ #if defined(BORLANDC) extern unsigned _stklen = BORLANDC_STACK_SIZE; extern unsigned _ovrbuffer = BORLANDC_OVERLAY_SIZE; #endif /****************************************************************************** * Global variables local to this source file. ******************************************************************************/ AOSs2A (openingLines, "Opening CDF...", "") AOSs2B (closingLines, "Closing CDF...", "") AOSs2C (delLines, "Deleting CDF...", "") /****************************************************************************** * Main. ******************************************************************************/ #if !defined(win32) MAIN { Logical success = TRUE; strcpyX (pgmName, "CDFedit", MAX_PROGRAM_NAME_LEN); #if defined(mac) MacExecuteFSI (EditCDFs, EditQOPs); #else success = EditCDFs (argc, argv); #endif #if defined(DEBUG) if (cdf_FreeMemory(NULL,FatalError) > 0) DisplayWarning ("Abandoned buffers."); #else cdf_FreeMemory (NULL, FatalError); #endif return BOO(success,EXIT_SUCCESS_,EXIT_FAILURE_); } #endif /****************************************************************************** * EditCDFs. ******************************************************************************/ Logical EditCDFs (argC, argV) int argC; char *argV[]; { QOP *qop; static char *validQuals[] = { "browse", "nobrowse", "zmode", "format", "noformat", "prompt", "noprompt", "report", "neg2posfp0", "noneg2posfp0", "cache", "statistics", "nostatistics", "gwithentries", "nogwithentries", "vwithentries", "novwithentries", "about", NULL }; static int optRequired[] = { FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 0 }; static char *reportTokens[] = { "errors", "warnings", "informationals" }; char CDFspec[DU_MAX_PATH_LEN+1]; Logical useFormat, promptForSpec, negToPosFp0, status; long zMode, workingCache, stageCache, compressCache; Logical qopError = FALSE; /*************************************************************************** * Check qualifiers/options/parameters. ***************************************************************************/ switch (argC) { case 1: InitializeScreen (); OnlineHelpWindow (olhFile, OLHhelpID); CleanupScreen (); return TRUE; default: qop = Qop (argC, argV, validQuals, optRequired); if (qop == NULL) return FALSE; /*********************************************************************** * Check for `about' qualifier. ***********************************************************************/ if (qop->qualEntered[ABOUTqual]) { DisplayIdentification (pgmName); cdf_FreeMemory (qop, FatalError); return TRUE; } /*********************************************************************** * Get CDF path parameter. ***********************************************************************/ switch (qop->Nparms) { case 0: CDFspec[0] = NUL; break; case 1: strcpyX (CDFspec, qop->parms[CDFSPECparm], DU_MAX_PATH_LEN); #if defined(vms) || defined(dos) MakeUpperString (CDFspec); #endif break; default: DisplayError ("Too many parameters."); qopError = TRUE; break; } /*********************************************************************** * Check for `browse', `format', `prompt', `neg2posfp0', and `statistics' * qualfiers. ***********************************************************************/ qopError = qopError | !TFqualifier(qop,&browseOnly,BROWSEqual, NOBROWSEqual,DEFAULTbrowseEDIT, "browse"); qopError = qopError | !TFqualifier(qop,&useFormat,FORMATqual, NOFORMATqual,DEFAULTformatEDIT, "format"); qopError = qopError | !TFqualifier(qop,&promptForSpec,PROMPTqual, NOPROMPTqual,DEFAULTpromptEDIT, "prompt"); qopError = qopError | !TFqualifier(qop,&negToPosFp0,NEG2POSFP0qual, NONEG2POSFP0qual,DEFAULT_NEGtoPOSfp0, "neg2posfp0"); qopError = qopError | !TFqualifier(qop,&dumpStatistics,STATSqual, NOSTATSqual,DEFAULTstatsEDIT, "statistics"); qopError = qopError | !TFqualifier(qop,&gAttrsAndEntries,gWITHqual, NOgWITHqual,DEFAULTgWithEDIT, "gwithentries"); qopError = qopError | !TFqualifier(qop,&vAttrsAndEntries,vWITHqual, NOvWITHqual,DEFAULTvWithEDIT, "vwithentries"); /*********************************************************************** * Check for zMode qualifier. ***********************************************************************/ if (qop->qualEntered[ZMODEqual]) { switch (qop->qualOpt[ZMODEqual][0]) { case '0': zMode = zMODEoff; break; case '1': zMode = zMODEon1; break; case '2': zMode = zMODEon2; break; default: { char tempS[MAX_MESSAGE_TEXT_LEN+1]; sprintf (tempS, "Illegal zMode (%s).", qop->qualOpt[ZMODEqual]); DisplayError (tempS); qopError = TRUE; } } } else zMode = DEFAULTzModeEDIT; /*********************************************************************** * Check for `cache' qualifier. ***********************************************************************/ if (qop->qualEntered[CACHEqual]) { if (!ParseCacheSizes(qop->qualOpt[CACHEqual], &workingCache,&stageCache,&compressCache)) { DisplayError ("Illegal cache size/type."); qopError = TRUE; } } else { workingCache = useDEFAULTcacheSIZE; stageCache = useDEFAULTcacheSIZE; compressCache = useDEFAULTcacheSIZE; } /*********************************************************************** * Check for `report' qualifier. If absent, use defaults. ***********************************************************************/ if (qop->qualEntered[REPORTqual]) { if (!ParseOptionList(3,reportTokens, qop->qualOpt[REPORTqual],report)) { DisplayError ("Illegal list of `report' options."); qopError = TRUE; } } else { report[ERRORs] = REPORTerrorsDEFAULT; report[WARNs] = REPORTwarningsDEFAULT; report[INFOs] = REPORTinfosDEFAULT; } /*********************************************************************** * Check for missing/conflicting parameters/qualifiers. ***********************************************************************/ if (qop->Nparms < 1 && (!promptForSpec)) { DisplayError ("Enter CDF(s) specification or `prompt' qualifier."); qopError = TRUE; } /*********************************************************************** * Free QOP memory and check for an error. ***********************************************************************/ cdf_FreeMemory (qop, FatalError); if (qopError) return FALSE; break; } /*************************************************************************** * Initialize. ***************************************************************************/ if (browseOnly) { strcpyX (pgmName, "CDFbrowse", MAX_PROGRAM_NAME_LEN); strcpyX (ilhFile, "cdfbrow.ilh", MAX_ILHFILE_LEN); } else strcpyX (ilhFile, "cdfedit.ilh", MAX_ILHFILE_LEN); InitializeScreen (); /*************************************************************************** * Edit CDF(s). ***************************************************************************/ if (promptForSpec) status = SpecificationPrompt (CDFspec, useFormat, negToPosFp0, zMode, workingCache, stageCache, compressCache); else if (IsDir(CDFspec) || IsWild(CDFspec)) status = EditCDFsMenu (CDFspec, negToPosFp0, useFormat, zMode, workingCache, stageCache, compressCache); else status = TryToEditCDF (CDFspec, negToPosFp0, useFormat, zMode, workingCache, stageCache, compressCache); /*************************************************************************** * Clean up screen and return. ***************************************************************************/ CleanupScreen (); return status; } /****************************************************************************** * SpecificationPrompt. ******************************************************************************/ Logical SpecificationPrompt (CDFspec, useFormat, negToPosFp0, zMode, workingCache, stageCache, compressCache) char CDFspec[DU_MAX_PATH_LEN+1]; Logical useFormat; Logical negToPosFp0; long zMode; long workingCache; long stageCache; long compressCache; { for (;;) { if (NULstring(CDFspec)) strcpyX (CDFspec,CURRENTDIRECTORY,DU_MAX_PATH_LEN); if (!PromptForSpec(CDFspec)) break; #if defined(vms) || defined(dos) MakeUpperString (CDFspec); #endif if (IsDir(CDFspec) || IsWild(CDFspec)) { /************************************************************************ * Directory/wildcard (more than one CDF). ************************************************************************/ if (!EditCDFsMenu(CDFspec,negToPosFp0,useFormat, zMode,workingCache,stageCache, compressCache)) return FALSE; } else { /************************************************************************ * Assumed to be a complete specification of a single CDF. ************************************************************************/ TryToEditCDF (CDFspec, negToPosFp0, useFormat, zMode, workingCache, stageCache, compressCache); } } return TRUE; } /****************************************************************************** * EditCDFsMenu. ******************************************************************************/ Logical EditCDFsMenu (CDFspec, negToPosFp0, useFormat, zMode, workingCache, stageCache, compressCache) char *CDFspec; Logical negToPosFp0; Logical useFormat; long zMode; long workingCache; long stageCache; long compressCache; { CDFstatus status; int nCDFs; char **dirS, **CDFs; char CDFdir[DU_MAX_DIR_LEN+1], CDFname[DU_MAX_NAME_LEN+1]; char CDFpathT[DU_MAX_PATH_LEN+1]; char CDFfullPath[DU_MAX_PATH_LEN+1]; static char label[16+DU_MAX_PATH_LEN+2+1]; static Logical first = TRUE; AOSs1 (header, BLANKs78) AOSs2 (trailerEdit, "Edit: ________ Exit: ________ Help: ________", "Create: ________ Delete: ________ Info: ________") AOSs1A (trailerBrowse, "Browse: ________ Exit: ________ Info: ________ Help: ________") static int exitCharsEdit[] = { ENTERkey_FSI, EXITkey_FSI, CREATECDFkey_EDIT, DELETECDFkey_EDIT, HELPkey_FSI, INFOkey_EDIT, NUL }; static int exitCharsBrowse[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, INFOkey_EDIT, NUL }; static struct ItemWindowStruct IW = { 0, 0, 80, label, 1, header, 0, NULL, 0, NULL, NULL, NULL, 0, 0, NULL, NULL, REFRESHkey_FSI, TRUE, NSkey_FSI, PSkey_FSI }; AOSs6 (infoLines, BLANKs78, BLANKs78, BLANKs78, " ", "Enter any key to continue...", "") static char noneMsg[] = { "No CDF selected (no CDFs exist for this specification)." }; /**************************************************************************** * First time... ****************************************************************************/ if (first) { EncodeKeyDefinitions (1, trailerBrowse, ENTERkey_FSI, EXITkey_FSI, INFOkey_EDIT, HELPkey_FSI); EncodeKeyDefinitions (2, trailerEdit, ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, CREATECDFkey_EDIT, DELETECDFkey_EDIT, INFOkey_EDIT); first = FALSE; } if (browseOnly) { IW.NiRows = 15; IW.NtLines = 1; IW.tLines = trailerBrowse; IW.exitChars = exitCharsBrowse; } else { IW.NiRows = 14; IW.NtLines = 2; IW.tLines = trailerEdit; IW.exitChars = exitCharsEdit; } ParsePath (CDFspec, CDFdir, CDFname); BuildCDFsMenu (CDFspec, &nCDFs, &dirS, &CDFs, &IW); ItemWindow (NEWiw, &IW, 0); for (;;) { ItemWindow (READiw, &IW); switch (IW.key) { /*********************************************************************** * Edit currently selected CDF. The CDFs menu is rebuild/updated in * case the CDF was deleted. When the CDFs menu is updated, the new * current item is set to the old current item (or the last item in * case more than one CDF was deleted [possibly by another user]). * If the CDF was deleted, the new current item should be the CDF * that followed it in the list (unless it was the last CDF in which * case the new current item will be the last CDF in the new list). ***********************************************************************/ case ENTERkey_FSI: if (IW.nItems == 0) { ProblemWindow (noneMsg, FALSE); } else { CDFid id; int lastItemN; Logical isLFS; strcpyX (CDFpathT, dirS[IW.itemN], DU_MAX_PATH_LEN); AppendToDir (CDFpathT, CDFs[IW.itemN]); status = CheckLFS (CDFpathT, &isLFS, CDFfullPath); compressed = CompressedCDF (CDFfullPath); if (compressed) { MessageWindow (openingLines, NULL, LogicalFALSE); zzzzz (1.0); } status = CDFlib (OPEN_, CDF_, CDFfullPath, &id, NULL_); if (compressed) MessageWindow (NULL); ReportStatus (status, FALSE); if (StatusBAD(status)) break; ItemWindow (UNDISPLAYiw, &IW); EditCDF (CDFs[IW.itemN], useFormat, workingCache, stageCache, compressCache, zMode, negToPosFp0); FreeCDFsMenu (dirS, CDFs, &IW); BuildCDFsMenu (CDFspec, &nCDFs, &dirS, &CDFs, &IW); lastItemN = IW.nItems - 1; ItemWindow (UPDATEiw, &IW, MINIMUM(IW.itemN,lastItemN)); ItemWindow (REDISPLAYiw, &IW); } break; /*********************************************************************** * Display `info' for currently selected CDF. ***********************************************************************/ case INFOkey_EDIT: if (IW.nItems == 0) { ProblemWindow (noneMsg, FALSE); } else { long cType, cParms[CDF_MAX_PARMS], cFileSize1, uFileSize1; OFF_T cFileSize2, uFileSize2; Logical isLFS; strcpyX (CDFpathT, dirS[IW.itemN], DU_MAX_PATH_LEN); AppendToDir (CDFpathT, CDFs[IW.itemN]); status = CheckLFS(CDFpathT, &isLFS, CDFfullPath); if (isLFS) status = CDFlib (GET_, CDF_INFO_, CDFfullPath, &cType, cParms, &cFileSize1, &uFileSize1, NULL_); else status = CDFlib (GET_, CDF_INFO_, CDFfullPath, &cType, cParms, &cFileSize2, &uFileSize2, NULL_); ReportStatus (status, FALSE); if (StatusOK(status)) { char label[DU_MAX_NAME_LEN+13+1]; sprintf (label, " Info for `%s' ", CDFs[IW.itemN]); sprintf (infoLines[0], "Compression: %s", CompressionToken(cType,cParms)); if (cType == NO_COMPRESSION) { if (isLFS) #if !defined(win32) sprintf (infoLines[1], "Uncompressed: %lld bytes", uFileSize2); #else sprintf (infoLines[1], "Uncompressed: %I64d bytes", uFileSize2); #endif else sprintf (infoLines[1], "Uncompressed: %ld bytes", uFileSize1); MakeNUL (infoLines[2]); } else { if (isLFS) { #if !defined(win32) sprintf (EofS(infoLines[0]), " (%ld%%)", (long) (((OFF_T)100 * cFileSize2) / uFileSize2)); sprintf (infoLines[1], "Compressed: %lld bytes", cFileSize2); sprintf (infoLines[2], "Uncompressed: %lld bytes", uFileSize2); #else sprintf (EofS(infoLines[0]), " (%ld%%)", (long) (((OFF_T)100 * cFileSize2) / uFileSize2)); sprintf (infoLines[1], "Compressed: %I64d bytes", cFileSize2); sprintf (infoLines[2], "Uncompressed: %I64d bytes", uFileSize2); #endif } else { sprintf (EofS(infoLines[0]), " (%ld%%)", ((100L * cFileSize1) / uFileSize1)); sprintf (infoLines[1], "Compressed: %ld bytes", cFileSize1); sprintf (infoLines[2], "Uncompressed: %ld bytes", uFileSize1); } } MessageWindow (infoLines, label, LogicalTRUE); MessageWindow (NULL); } } break; /*********************************************************************** * Create a CDF. * Note that `CreateCDF' will undisplay this window (if necessary). ***********************************************************************/ case CREATECDFkey_EDIT: { char CDFnameT[DU_MAX_NAME_LEN+1]; int itemN; strcpyX (CDFnameT, "", DU_MAX_NAME_LEN); CreateCDF (CDFdir, CDFnameT, zMode, useFormat, negToPosFp0, workingCache, stageCache, compressCache, &IW); FreeCDFsMenu (dirS, CDFs, &IW); BuildCDFsMenu (CDFspec, &nCDFs, &dirS, &CDFs, &IW); itemN = IndexInList (CDFnameT, nCDFs, CDFs); ItemWindow (UPDATEiw, &IW, BOO(itemN < 0,0,itemN)); ItemWindow (REDISPLAYiw, &IW); break; } /*********************************************************************** * Delete currently selected CDF. When the CDFs menu is updated, the * new current item is set to the old current item (or the last item * in case more than one CDF was deleted [possibly by another user]). * The new current item should be the CDF (in the list) that followed * the CDF that was deleted (unless it was the last CDF in which case * the new current item will be the last CDF in the new list). ***********************************************************************/ case DELETECDFkey_EDIT: if (IW.nItems == 0) { ProblemWindow (noneMsg, FALSE); } else { char delim, question[DU_MAX_NAME_LEN+15+1]; delim = PickDelimiter (CDFs[IW.itemN],strlen(CDFs[IW.itemN])); sprintf (question, "Delete CDF %c%s%c ?", delim, CDFs[IW.itemN], delim); if (ConfirmWindow(3,78,question,NULL,FALSE,DELETECDFhelpID)) { CDFid id; CDFstatus status; int lastItemN; Logical isLFS; strcpyX (CDFpathT, dirS[IW.itemN], DU_MAX_PATH_LEN); AppendToDir (CDFpathT, CDFs[IW.itemN]); status = CheckLFS (CDFpathT, &isLFS, CDFfullPath); compressed = CompressedCDF (CDFfullPath); if (compressed) { MessageWindow (delLines, NULL, LogicalFALSE); zzzzz (1.0); } status = CDFlib (OPEN_, CDF_, CDFfullPath, &id, DELETE_, CDF_, NULL_); if (compressed) MessageWindow (NULL); ReportStatus (status, FALSE); FreeCDFsMenu (dirS, CDFs, &IW); BuildCDFsMenu (CDFspec, &nCDFs, &dirS, &CDFs, &IW); lastItemN = IW.nItems - 1; ItemWindow (UPDATEiw, &IW, MINIMUM(IW.itemN,lastItemN)); } } break; /*********************************************************************** * Display online help. ***********************************************************************/ case HELPkey_FSI: OnlineHelpWindow (ilhFile, CDFShelpID); break; /*********************************************************************** * Exit. ***********************************************************************/ case EXITkey_FSI: ItemWindow (DELETEiw, &IW); FreeCDFsMenu (dirS, CDFs, &IW); return TRUE; } } } /****************************************************************************** * BuildCDFsMenu. ******************************************************************************/ void BuildCDFsMenu (CDFspec, nCDFs, dirS, CDFs, IW) char *CDFspec; int *nCDFs; char ***dirS; char ***CDFs; struct ItemWindowStruct *IW; { int CDFn; sprintf (IW->label, " Specification \"%s\" ", CDFspec); *nCDFs = CDFdirList (CDFspec, dirS, CDFs); sprintf (IW->hLines[0], "%d CDF%s", *nCDFs, (*nCDFs == 1 ? "" : "s")); if (*nCDFs > 0) { AllocIW (IW, *nCDFs, *nCDFs, CDFs_NAME_LEN, FatalError); for (CDFn = 0; CDFn < *nCDFs; CDFn++) { size_t nameLen = strlen((*CDFs)[CDFn]); strcpyX (IW->iLines[CDFn], (*CDFs)[CDFn], CDFs_NAME_LEN); IW->iLineNs[CDFn] = CDFn; IW->iCols[CDFn] = 0; IW->iLens[CDFn] = (int) MINIMUM(CDFs_NAME_LEN,nameLen); } } else { IW->NiLines = 0; IW->nItems = 0; } return; } /****************************************************************************** * FreeCDFsMenu. ******************************************************************************/ void FreeCDFsMenu (dirS, CDFs, IW) char **dirS; char **CDFs; struct ItemWindowStruct *IW; { if (dirS != NULL) cdf_FreeMemory (dirS, FatalError); if (CDFs != NULL) cdf_FreeMemory (CDFs, FatalError); FreeIW (IW, FatalError); return; } /****************************************************************************** * TryToEditCDF. ******************************************************************************/ Logical TryToEditCDF (CDFspec, negToPosFp0, useFormat, zMode, workingCache, stageCache, compressCache) char *CDFspec; Logical negToPosFp0; Logical useFormat; long zMode; long workingCache; long stageCache; long compressCache; { CDFstatus status; CDFid id; char CDFdir[DU_MAX_DIR_LEN+1], CDFname[DU_MAX_NAME_LEN+1]; char CDFfullName[DU_MAX_NAME_LEN+1]; Logical isLFS; ParsePath (CDFspec, CDFdir, CDFname); status = CheckLFS (CDFspec, &isLFS, CDFfullName); compressed = FALSE; if (status == CDF_OK) { compressed = CompressedCDF (CDFfullName); if (compressed) { MessageWindow (openingLines, NULL, LogicalFALSE); zzzzz (1.0); } } status = CDFlib (OPEN_, CDF_, CDFfullName, &id, NULL_); if (compressed) MessageWindow (NULL); switch (status) { case NO_SUCH_CDF: if (!browseOnly) { char delim, question[DU_MAX_PATH_LEN+29+1]; int helpID; delim = PickDelimiter(CDFfullName, strlen(CDFfullName)); if (CDFgetFileBackwardEnvVar() == 1) { sprintf (question, "CDF %c%s%c does not exist. Create?", delim, CDFfullName, delim); } else { sprintf (question, "CDF %c%s%c does not exist. Create(V3 or V2.7)?", delim, CDFfullName, delim); helpID = CREATECDFV23helpID; } if (ConfirmWindow2(3,78,question,NULL,TRUE,helpID)) { if (!CreateCDF(CDFdir,CDFname,zMode, useFormat,negToPosFp0, workingCache, stageCache, compressCache,NULL)) return FALSE; } } else ProblemWindow ("CDF does not exist.", TRUE); break; default: ReportStatus (status, TRUE); if (StatusBAD(status)) return FALSE; if (!EditCDF(CDFname,useFormat,workingCache,stageCache, compressCache,zMode,negToPosFp0)) return FALSE; break; } return TRUE; } /****************************************************************************** * CreateCDF. ******************************************************************************/ Logical CreateCDF (CDFdir, CDFname, zMode, useFormat, negToPosFp0, workingCache, stageCache, compressCache, IWcdfs) char *CDFdir; /* Directory in which to create CDF. */ char *CDFname; /* If null-string (""), then prompt for name. Returns name entered here. */ long zMode; /* The zMode to select after CDF is created. */ Logical useFormat; /* TRUE if FORMAT attribute should be used. */ Logical negToPosFp0; /* TRUE if conversion of -0.0 to +0.0 should be selected after CDF is created. */ long workingCache; /* Number of cache buffers for the "working" dotCDF file. */ long stageCache; /* Number of cache buffers for the staging file. */ long compressCache; /* Number of cache buffers for the compression scratch file. */ struct ItemWindowStruct *IWcdfs; /* Pointer to "CDFs Menu" widget. If NULL, then this routine was not called from the "CDFs Menu". */ { CDFstatus status; CDFid id; static Logical first = TRUE; long numDims, dimSizes[CDF_MAX_DIMS]; char CDFpathT[DU_MAX_PATH_LEN+1], delim; AOSs1 (trailer, "Enter: ________ Exit: ________ Help: ________") static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL }; static char *headerDim[] = { "Enter rVariable dimensionality...", "Syntax: :[,,...,]", "Examples: 0:[], 1:[5], 2:[100,100], 3:[10,20,30]" }; static char valueDim[MAX_DIMENSIONALITY_LEN+1]; static char labelDim[8+DU_MAX_NAME_LEN+1]; static struct PromptWindowStruct PWdim = { labelDim, 3, 1, 78, 3, headerDim, MAX_DIMENSIONALITY_LEN, valueDim, 1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI }; if (first) { EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI); first = FALSE; } if (NULstring(CDFname)) { static char *header[] = { "Enter CDF name (without delimiters)...", "Syntax: ...", "Example: D104B" }; static char label[13+1+DU_MAX_DIR_LEN+1+1+1]; static struct PromptWindowStruct PW = { label, 3, 1, 78, 3, header, DU_MAX_NAME_LEN, NULL, 1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI }; char dirT[DU_MAX_DIR_LEN+1]; strcpyX (dirT, (NULstring(CDFdir) ? CURRENTDIRECTORY : CDFdir), DU_MAX_DIR_LEN); delim = PickDelimiter (dirT, strlen(dirT)); sprintf (PW.label, " Creating in %c%s%c ", delim, dirT, delim); PW.value = CDFname; PromptWindow (NEWpw, &PW, 0, LogicalTRUE); for (;;) { if (EnterPW(&PW,CDFNAMEhelpID)) if (strlen(CDFname) > (size_t) 0) { #if defined(vms) || defined(dos) MakeUpperString (CDFname); #endif begin_pasteboard_update (); /* Used to prevent the flicker between this prompt and the next one. */ PromptWindow (DELETEpw, &PW); break; } else ProblemWindow ("Illegal CDF name.", FALSE); else { PromptWindow (DELETEpw, &PW); return TRUE; } } } strcpyX (CDFpathT, CDFdir, DU_MAX_PATH_LEN); AppendToDir (CDFpathT, CDFname); strcpyX (PWdim.value, "0:[]", MAX_DIMENSIONALITY_LEN); delim = PickDelimiter (CDFname, strlen(CDFname)); sprintf (labelDim, " CDF %c%s%c ", delim, CDFname, delim); PromptWindow (NEWpw, &PWdim, (int) strlen(PWdim.value), LogicalTRUE); end_pasteboard_update (); /* It is OK to call this in the case where the `begin_pasteboard_update' above was not called (because the CDF name was not prompted for. */ for (;;) { if (EnterPW(&PWdim,RDIMhelpID)) { if (DecodeDimensionality(PWdim.value,&numDims,dimSizes)) { PromptWindow (DELETEpw, &PWdim); break; } else ProblemWindow ("Illegal dimensionality.", FALSE); } else { PromptWindow (DELETEpw, &PWdim); return TRUE; } } status = CDFlib (CREATE_, CDF_, CDFpathT, numDims, dimSizes, &id, NULL_); ReportStatus (status, FALSE); if (StatusBAD(status)) return FALSE; compressed = FALSE; if (IWcdfs != NULL) ItemWindow (UNDISPLAYiw, IWcdfs); return EditCDF(CDFname,useFormat,workingCache,stageCache,compressCache, zMode,negToPosFp0); } /****************************************************************************** * EditCDF. ******************************************************************************/ Logical EditCDF (CDFname, useFormat, workingCache, stageCache, compressCache, zMode, negToPosFp0) char *CDFname; Logical useFormat; long workingCache; long stageCache; long compressCache; long zMode; Logical negToPosFp0; { Logical status, closed = FALSE; /**************************************************************************** * Edit the CDF. ****************************************************************************/ status = EditCDFx(CDFname,useFormat,workingCache,stageCache,compressCache, zMode,negToPosFp0,&closed); if (!closed) CDFlib (CLOSE_, CDF_, NULL_); /**************************************************************************** * Return the conversion status. ****************************************************************************/ return status; } /****************************************************************************** * EditCDFx. ******************************************************************************/ Logical EditCDFx (CDFname, useFormat, workingCache, stageCache, compressCache, zMode, negToPosFp0, closed) char *CDFname; Logical useFormat; long workingCache; long stageCache; long compressCache; long zMode; Logical negToPosFp0; Logical *closed; { CDFstatus status; long readonlyMode = BOO(browseOnly,READONLYon,READONLYoff); long negToPosFp0Mode = BOO(negToPosFp0,NEGtoPOSfp0on,NEGtoPOSfp0off); AOSs3 (hLines, BLANKs78, BLANKs78, BLANKs78) static Logical first = TRUE; static char *iLinesBrowse[] = { "", "", "", "" }; static char *iLinesEdit[] = { " ", " ", " ", " " }; AOSs1A (tLinesBrowse, "Select: ________ Exit: ________ Help: ________") AOSs1B (tLinesEdit, "Select: ________ Delete: ________ Exit: ________ Help: ________") static int iLineNsBrowse[] = { 0, 1, 2, 3 }; static int iColsBrowse[] = { 0, 0, 0, 0 }; static int iLensBrowse[] = { 19, 19, 20, 20 }; static int iLineNsEdit[] = { 0, 0, 0, 1, 1, 2, 2, 3, 3 }; static int iColsEdit[] = { 0, 20, 43, 0, 20, 0, 20, 0, 20 }; static int iLensEdit[] = { 17, 20, 17, 17, 17, 18, 17, 18, 15 }; static int exitCharsBrowse[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, zMODE0key_EDIT, zMODE1key_EDIT, zMODE2key_EDIT, NUL }; static int exitCharsEdit[] = { ENTERkey_FSI, EXITkey_FSI, DELETECDFkey_EDIT, HELPkey_FSI, zMODE0key_EDIT, zMODE1key_EDIT, zMODE2key_EDIT, NUL }; static char label[6+DU_MAX_NAME_LEN+2+1]; static struct ItemWindowStruct IW = { 0, 0, 80, label, 3, hLines, 0, NULL, 0, NULL, NULL, NULL, 4, 1, NULL, NULL, REFRESHkey_FSI, FALSE, NUL, NUL }; /*************************************************************************** * First time... ***************************************************************************/ if (first) { EncodeKeyDefinitions (1, tLinesBrowse, ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI); EncodeKeyDefinitions (1, tLinesEdit, ENTERkey_FSI, DELETECDFkey_EDIT, EXITkey_FSI, HELPkey_FSI); first = FALSE; } if (browseOnly) { IW.NiLines = 4; IW.iLines = iLinesBrowse; IW.nItems = 4; IW.iLineNs = iLineNsBrowse; IW.iCols = iColsBrowse; IW.iLens = iLensBrowse; IW.tLines = tLinesBrowse; IW.exitChars = exitCharsBrowse; } else { IW.NiLines = 4; IW.iLines = iLinesEdit; IW.nItems = 9; IW.iLineNs = iLineNsEdit; IW.iCols = iColsEdit; IW.iLens = iLensEdit; IW.tLines = tLinesEdit; IW.exitChars = exitCharsEdit; } /*************************************************************************** * Try to set number of cache buffers for dotCDF file, read-only mode, zMode, * and -0.0 mode. ***************************************************************************/ status = CDFlib (SELECT_, CDF_CACHESIZE_, workingCache, STAGE_CACHESIZE_, stageCache, COMPRESS_CACHESIZE_, compressCache, CDF_READONLY_MODE_, readonlyMode, CDF_zMODE_, zMode, CDF_NEGtoPOSfp0_MODE_, negToPosFp0Mode, NULL_); if (!ReportStatus(status,FALSE)) return FALSE; /*************************************************************************** * Build main menu. ***************************************************************************/ if (!BuildCDFmenu(CDFname,&IW)) return FALSE; /*************************************************************************** * Display menu/process keystrokes. ***************************************************************************/ ItemWindow (NEWiw, &IW, 0); for (;;) { ItemWindow (READiw, &IW); switch (IW.key) { /*********************************************************************** * Perform selected function. ***********************************************************************/ case ENTERkey_FSI: { int itemNt = IW.itemN + BOO(browseOnly,BROWSEinOFFSET,0); switch (itemNt) { /******************************************************************* * Edit rVariables. *******************************************************************/ case EDITrVarsIN: case BROWSErVarsIN: case EDITzVarsIN: case BROWSEzVarsIN: { Logical zOp = (itemNt == EDITzVarsIN || itemNt == BROWSEzVarsIN); ItemWindow (UNDISPLAYiw, &IW); if (!EditVars(zOp,CDFname,useFormat)) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); ItemWindow (REDISPLAYiw, &IW); break; } /******************************************************************* * Edit gAttributes. *******************************************************************/ case EDITgAttrsIN: case BROWSEgAttrsIN: ItemWindow (UNDISPLAYiw, &IW); if (gAttrsAndEntries) { if (!EditAttrs(TRUE,CDFname)) { ItemWindow (DELETEiw, &IW); return FALSE; } } else { if (!EditAttrsX(TRUE,CDFname)) { ItemWindow (DELETEiw, &IW); return FALSE; } } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); ItemWindow (REDISPLAYiw, &IW); break; /******************************************************************* * Edit vAttributes. *******************************************************************/ case EDITvAttrsIN: case BROWSEvAttrsIN: ItemWindow (UNDISPLAYiw, &IW); if (vAttrsAndEntries) { if (!EditAttrs(FALSE,CDFname)) { ItemWindow (DELETEiw, &IW); return FALSE; } } else { if (!EditAttrsX(FALSE,CDFname)) { ItemWindow (DELETEiw, &IW); return FALSE; } } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); ItemWindow (REDISPLAYiw, &IW); break; /******************************************************************* * Change format: *******************************************************************/ case CHANGEformatIN: { if (!SelectFormat()) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); break; } /******************************************************************* * Change encoding: *******************************************************************/ case CHANGEencodingIN: { if (!SelectEncoding()) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); break; } /******************************************************************* * Change majority: *******************************************************************/ case CHANGEmajorityIN: { if (!SelectMajority()) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); break; } /******************************************************************* * Select CDF compression: *******************************************************************/ case CHANGEcompressionIN: if (!SelectCompression(FORCDF,12,NULL)) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); break; /******************************************************************* * Change checksum: *******************************************************************/ case CHANGEchecksumIN: { if (!SelectChecksum()) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); break; } } break; } /*********************************************************************** * Delete CDF. ***********************************************************************/ case DELETECDFkey_EDIT: if (!browseOnly) { char delim, question[DU_MAX_NAME_LEN+15+1]; delim = PickDelimiter (CDFname, strlen(CDFname)); sprintf (question, "Delete CDF %c%s%c ?", delim, CDFname, delim); if (ConfirmWindow(12,80,question,NULL,FALSE,DELETECDFhelpID)) { status = CDFlib (DELETE_, CDF_, NULL_); if (ReportStatus(status,FALSE)) { ItemWindow (DELETEiw, &IW); *closed = TRUE; return TRUE; } if (NoMoreAccess(NULL)) { ItemWindow (DELETEiw, &IW); return FALSE; } } } else ProblemWindow ("Deleting a CDF not allowed while browsing.", FALSE); break; /*********************************************************************** * zMode selection keys. ***********************************************************************/ case zMODE0key_EDIT: case zMODE1key_EDIT: case zMODE2key_EDIT: { long zMode; switch (IW.key) { case zMODE0key_EDIT: zMode = zMODEoff; break; case zMODE1key_EDIT: zMode = zMODEon1; break; case zMODE2key_EDIT: zMode = zMODEon2; break; } status = CDFlib (SELECT_, CDF_zMODE_, zMode, NULL_); if (!ReportStatus(status,FALSE)) { ItemWindow (DELETEiw, &IW); return FALSE; } if (!BuildCDFmenu(CDFname,&IW)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (UPDATEiw, &IW, IW.itemN); break; } /*********************************************************************** * Display online help. ***********************************************************************/ case HELPkey_FSI: OnlineHelpWindow (ilhFile, CDFhelpID); break; /*********************************************************************** * Exit menu (closing CDF). ***********************************************************************/ case EXITkey_FSI: { if (dumpStatistics) { vSTATS vStatsDotCDF, vStatsStage, vStatsCompress; char temp1[MAX_SCREENLINE_LEN+1], temp2[MAX_SCREENLINE_LEN+1], temp3[MAX_SCREENLINE_LEN+1]; if (compressed) { MessageWindow (closingLines, NULL, LogicalFALSE); zzzzz (1.0); } status = CDFlib (CLOSE_, CDFwithSTATS_, &vStatsDotCDF, &vStatsStage, &vStatsCompress, NULL_); if (compressed) MessageWindow (NULL); *closed = TRUE; if (!ReportStatus(status,FALSE)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (DELETEiw, &IW); if (vStatsDotCDF.maxBuffers > 0) { BuildStatistics ("DotCDF file", &vStatsDotCDF, temp1, temp2, temp3); InfoWindow (temp1, temp2, temp3, TRUE, FALSE, 0); } if (vStatsStage.maxBuffers > 0) { BuildStatistics ("staging file", &vStatsStage, temp1, temp2, temp3); InfoWindow (temp1, temp2, temp3, TRUE, FALSE, 0); } if (vStatsCompress.maxBuffers > 0) { BuildStatistics ("compression scratch file", &vStatsCompress, temp1, temp2, temp3); InfoWindow (temp1, temp2, temp3, TRUE, FALSE, 0); } } else { if (compressed) { MessageWindow (closingLines, NULL, LogicalFALSE); zzzzz (1.0); } status = CDFlib (CLOSE_, CDF_, NULL_); if (compressed) MessageWindow (NULL); *closed = TRUE; if (!ReportStatus(status,FALSE)) { ItemWindow (DELETEiw, &IW); return FALSE; } ItemWindow (DELETEiw, &IW); } return TRUE; } } } } /****************************************************************************** * BuildCDFmenu. ******************************************************************************/ Logical BuildCDFmenu (CDFname, IW) char *CDFname; struct ItemWindowStruct *IW; { CDFstatus status; long format, encoding, majority, checksum; long nAttrs, NgAttrs, NvAttrs, NrVars, NzVars; long version, release, increment; long cType, cParms[CDF_MAX_PARMS], cPct; int pad; /**************************************************************************** * Encode label with name of CDF. ****************************************************************************/ sprintf (IW->label, " CDF \"%s\" ", CDFname); /**************************************************************************** * Inquire CDF. ****************************************************************************/ status = CDFlib (GET_, CDF_FORMAT_, &format, CDF_ENCODING_, &encoding, CDF_MAJORITY_, &majority, CDF_NUMATTRS_, &nAttrs, CDF_NUMgATTRS_, &NgAttrs, CDF_NUMvATTRS_, &NvAttrs, CDF_NUMrVARS_, &NrVars, CDF_NUMzVARS_, &NzVars, CDF_VERSION_, &version, CDF_RELEASE_, &release, CDF_INCREMENT_, &increment, CDF_COMPRESSION_, &cType, cParms, &cPct, CDF_CHECKSUM_, &checksum, NULL_); if (!ReportStatus(status,FALSE)) return FALSE; /**************************************************************************** * Encode first line of header. ****************************************************************************/ sprintf (IW->hLines[0], "Format: %s", FormatToken(format)); pad = MAIN_MENU_1st_THIRD_LEN - strlen(IW->hLines[0]); if (pad > 0) CatNcharacters (IW->hLines[0], pad, (int) ' '); sprintf (EofS(IW->hLines[0]), "Attributes: %ld (%ldg/%ldv)", nAttrs, NgAttrs, NvAttrs); pad = MAIN_MENU_2nd_THIRD_LEN - strlen(IW->hLines[0]); if (pad > 0) CatNcharacters (IW->hLines[0], pad, (int) ' '); sprintf (EofS(IW->hLines[0]), "Compression: %s", CompressionToken(cType,cParms)); #if 0 if (cType != NO_COMPRESSION && cPct > 0) { sprintf (EofS(IW->hLines[0]), " (%ld%%)", cPct); } #endif /**************************************************************************** * Encode second line of header. ****************************************************************************/ sprintf (IW->hLines[1], "Majority: %s", MajorityToken(majority)); pad = MAIN_MENU_1st_THIRD_LEN - strlen(IW->hLines[1]); if (pad > 0) CatNcharacters (IW->hLines[1], pad, (int) ' '); sprintf (EofS(IW->hLines[1]), "Variables: %ld (%ldr/%ldz)", NrVars + NzVars, NrVars, NzVars); pad = MAIN_MENU_2nd_THIRD_LEN - strlen(IW->hLines[1]); if (pad > 0) CatNcharacters (IW->hLines[1], pad, (int) ' '); sprintf (EofS(IW->hLines[1]), "Encoding: %s", EncodingToken(encoding)); /**************************************************************************** * Encode third line of header. ****************************************************************************/ sprintf (IW->hLines[2], "Version: %ld.%ld.%ld", version, release, increment); pad = MAIN_MENU_1st_THIRD_LEN - strlen(IW->hLines[2]); if (pad > 0) CatNcharacters (IW->hLines[2], pad, (int) ' '); sprintf (EofS(IW->hLines[2]), "Checksum: %s", ChecksumToken(checksum)); return TRUE; } /****************************************************************************** * PromptForSpec. * Prompt for the CDF(s) specification. Returns TRUE if a valid CDF(s) * specification was entered; FALSE otherwise. ******************************************************************************/ Logical PromptForSpec (CDFspec) char CDFspec[DU_MAX_PATH_LEN+1]; { static char *header[] = { "Enter CDF(s) specification (without delimiters)...", "Syntax: ...", #if defined(vms) "Examples: RAIN2, RAIN*, [-.SAMPLES], USER5:[CDF1]IJ01A" #endif #if (defined(unix) && !defined(__CYGWIN__) && !defined(__MINGW32__)) || \ defined(posixSHELL) "Examples: rain2, rain*, ../samples, ~/CDFs/ij01a" #endif #if defined(dos) "Examples: RAIN2, RAIN*, ..\\SAMPLES, B:\\CDF1\\IJ01A" #endif #if defined(win32) || defined(__CYGWIN__) || defined(__MINGW32__) "Examples: rain2, rain*, ..\\samples, b:\\cdf1\\ij01a" #endif #if defined(mac) "Examples: cacsst1, cac*, Boot:CDFs:, :samples" #endif }; #if BROWSEaware AOSs1 (trailer, "Enter: ________ Exit: ________ Help: ________ More help: ________") static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, MOREHELPkey_EDIT, NUL }; #else AOSs1 (trailer, "Enter: ________ Exit: ________ Help: ________") static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL }; #endif static char value[DU_MAX_PATH_LEN+1]; static struct PromptWindowStruct PW = { " Specification Prompt ", 5, 5, 70, 3, header, DU_MAX_PATH_LEN, value, 1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI }; #if BROWSEaware EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, MOREHELPkey_EDIT); #else EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI); #endif strcpyX (PW.value, CDFspec, DU_MAX_PATH_LEN); PromptWindow (NEWpw, &PW, (int) strlen(PW.value), LogicalTRUE); for (;;) { PromptWindow (READiw, &PW); switch (PW.key) { case ENTERkey_FSI: if (strlen(PW.value) > (size_t) 0) { strcpyX (CDFspec, PW.value, DU_MAX_PATH_LEN); PromptWindow (DELETEpw, &PW); return TRUE; } else ProblemWindow ("Illegal CDF(s) specification.", FALSE); break; case EXITkey_FSI: PromptWindow (DELETEpw, &PW); return FALSE; case HELPkey_FSI: OnlineHelpWindow (ilhFile, SPEChelpID); break; #if BROWSEaware case MOREHELPkey_EDIT: OnlineHelpWindow (ilhFile, MOREHELPhelpID); break; #endif } } } /****************************************************************************** * EditQOPs. * Returns TRUE if execution should continue. ******************************************************************************/ #if defined(mac) Logical EditQOPs (argC, argV) int *argC; char **argV[]; { DialogPtr dialogP; DialogRecord dRecord; WindowPtr behind = (WindowPtr) -1; ControlHandle controlHs[MAXIMUMin+1]; Rect iRect; short iType, i; #ifndef __MWERKS__ short itemN; #else SInt16 itemN; ModalFilterUPP FilterDialogQOPfsiUPP; FileFilterUPP FilterForCDFsUPP; UserItemUPP OutlineDefaultButtonUPP; #endif static Logical browseOnly = DEFAULTbrowseEDIT; static Logical useFormat = DEFAULTformatEDIT; static Logical negToPos = DEFAULT_NEGtoPOSfp0; static Logical promptFor = DEFAULTpromptEDIT; static Logical reportInfos = REPORTinfosDEFAULT; static Logical reportWarns = REPORTwarningsDEFAULT; static Logical reportErrors = REPORTerrorsDEFAULT; static Logical dispStats = DEFAULTstatsEDIT; static Logical gWith = DEFAULTgWithEDIT; static Logical vWith = DEFAULTgWithEDIT; static int zMode = DEFAULTzModeEDIT; static Str255 cacheText = "\p"; static Str255 CDFtext = "\p"; /**************************************************************************** * Create the dialog and get the control handles. ****************************************************************************/ dialogP = GetNewDialog (QOPri, &dRecord, behind); for (itemN = 1; itemN <= MAXIMUMin; itemN++) { GetDItem (dialogP, itemN, &iType, (Handle *) &controlHs[itemN], &iRect); } /**************************************************************************** * Set the control values. ****************************************************************************/ SetIText ((Handle) controlHs[CDFTEXTin], CDFtext); SetIText ((Handle) controlHs[CACHEin], cacheText); if (browseOnly) SetCtlValue (controlHs[BROWSEin], 1); if (useFormat) SetCtlValue (controlHs[FORMATin], 1); if (negToPos) SetCtlValue (controlHs[NEGZin], 1); if (promptFor) SetCtlValue (controlHs[PROMPTin], 1); if (reportInfos) SetCtlValue (controlHs[INFOin], 1); if (reportWarns) SetCtlValue (controlHs[WARNin], 1); if (reportErrors) SetCtlValue (controlHs[ERRORin], 1); if (dispStats) SetCtlValue (controlHs[STATSin], 1); if (gWith) SetCtlValue (controlHs[gWITHin], 1); if (vWith) SetCtlValue (controlHs[vWITHin], 1); SetCtlValue (controlHs[ZMODEinBASE+zMode], 1); #ifndef __MWERKS__ SetDItem (dialogP, (short) ODBin, (short) userItem, (Handle) OutlineDefaultButton, &iRect); #else OutlineDefaultButtonUPP = NewUserItemProc (OutlineDefaultButton); SetDItem (dialogP, (short) ODBin, (short) userItem, (Handle) OutlineDefaultButtonUPP, &iRect); #endif /**************************************************************************** * Display the dialog and wait for user actions. ****************************************************************************/ ShowWindow ((WindowPtr) dialogP); SetCursor (ARROW_CURSOR); #ifdef __MWERKS__ FilterDialogQOPfsiUPP = NewModalFilterProc(FilterDialogQOPfsi); #endif for (;;) { #ifndef __MWERKS__ ModalDialog (FilterDialogQOPfsi, &itemN); #else ModalDialog (FilterDialogQOPfsiUPP, &itemN); #endif switch (itemN) { /************************************************************************ * Ok. ************************************************************************/ case OKin: { int n; char tempS1[1+1]; /********************************************************************** * Get the value of each control. **********************************************************************/ GetIText ((Handle) controlHs[CDFTEXTin], CDFtext); GetIText ((Handle) controlHs[CACHEin], cacheText); browseOnly = GetCtlValue (controlHs[BROWSEin]); useFormat = GetCtlValue (controlHs[FORMATin]); negToPos = GetCtlValue (controlHs[NEGZin]); promptFor = GetCtlValue (controlHs[PROMPTin]); reportInfos = GetCtlValue (controlHs[INFOin]); reportWarns = GetCtlValue (controlHs[WARNin]); reportErrors = GetCtlValue (controlHs[ERRORin]); dispStats = GetCtlValue (controlHs[STATSin]); gWith = GetCtlValue (controlHs[gWITHin]); vWith = GetCtlValue (controlHs[vWITHin]); for (zMode = 0; zMode < 3; zMode++) { if (GetCtlValue(controlHs[ZMODEinBASE+zMode])) break; } /********************************************************************** * Build argc/argv. **********************************************************************/ *argC = 12 + BOO(NULpString(CDFtext),0,1) + BOO(NULpString(cacheText),0,2); *argV = (char **) cdf_AllocateMemory (*argC * sizeof(char *), FatalError); n = 0; MAKEstrARGv (argV, n, pgmName) MAKEbooARGv (argV, n, browseOnly, "-browse", "-nobrowse") MAKEbooARGv (argV, n, useFormat, "-format", "-noformat") MAKEbooARGv (argV, n, negToPos, "-neg2posfp0", "-noneg2posfp0") MAKEbooARGv (argV, n, promptFor, "-prompt", "-noprompt") MAKEbooARGv (argV, n, dispStats, "-statistics", "-nostatistics") MAKEbooARGv (argV, n, gWith, "-gwithentries", "-nogwithentries") MAKEbooARGv (argV, n, vWith, "-vwithentries", "-novwithentries") MAKEstrARGv (argV, n, "-zmode") sprintf (tempS1, "%d", zMode); MAKEstrARGv (argV, n, tempS1) MAKEstrARGv (argV, n, "-report") MAKEstrARGv (argV, n, StatusCodeReportOptions(reportErrors, reportWarns, reportInfos)) if (!NULpString(cacheText)) { MAKEstrARGv (argV, n, "-cache") PtoCstr (cacheText); MAKEstrARGv (argV, n, (char *) cacheText) CtoPstr ((char *) cacheText); } if (!NULpString(CDFtext)) { PtoCstr (CDFtext); MAKEstrARGv (argV, n, (char *) CDFtext) CtoPstr ((char *) CDFtext); } /********************************************************************** * Close the dialog and return. **********************************************************************/ #ifdef __MWERKS__ DisposeRoutineDescriptor(FilterDialogQOPfsiUPP); DisposeRoutineDescriptor(OutlineDefaultButtonUPP); #endif CloseDialog (dialogP); return TRUE; } /************************************************************************ * Help. ************************************************************************/ case HELPin: { int n; *argC = 1; *argV = (char **) cdf_AllocateMemory (*argC * sizeof(char *), FatalError); n = 0; MAKEstrARGv (argV, n, pgmName) #ifdef __MWERKS__ DisposeRoutineDescriptor(FilterDialogQOPfsiUPP); DisposeRoutineDescriptor(OutlineDefaultButtonUPP); #endif CloseDialog (dialogP); return TRUE; } /************************************************************************ * Cancel. ************************************************************************/ case CANCELin: #ifdef __MWERKS__ DisposeRoutineDescriptor(FilterDialogQOPfsiUPP); DisposeRoutineDescriptor(OutlineDefaultButtonUPP); #endif CloseDialog (dialogP); return FALSE; /************************************************************************ * Select CDF specification (existing CDF). ************************************************************************/ case CDFSELECTin: { StandardFileReply CDFreply; char CDFpath[DU_MAX_PATH_LEN+1]; #ifndef __MWERKS__ StandardGetFile (FilterForCDFs, -1, NULL, &CDFreply); #else FilterForCDFsUPP = NewFileFilterProc(FilterForCDFs); StandardGetFile (FilterForCDFsUPP, -1, NULL, &CDFreply); DisposeRoutineDescriptor(FilterForCDFsUPP); #endif if (CDFreply.sfGood && !CDFreply.sfIsFolder && !CDFreply.sfIsVolume) { BuildMacPath (&CDFreply.sfFile, CDFpath, TRUE); CDFtext[0] = strlen (CDFpath); strcpyX ((char *) &CDFtext[1], CDFpath, 255); SetIText ((Handle) controlHs[CDFTEXTin], CDFtext); } break; } /************************************************************************ * Select CDF specification (new CDF). * The cursor is set because `StandardPutFile' leaves the cursor as * an iBeam (instead of returning it to what it was). ************************************************************************/ case CDFNEWin: { StandardFileReply CDFreply; char CDFpath[DU_MAX_PATH_LEN+1]; char prompt[] = "Enter CDF name:"; StandardPutFile (CtoPstr(prompt), CtoPstr(""), &CDFreply); if (CDFreply.sfGood && !CDFreply.sfIsFolder && !CDFreply.sfIsVolume) { BuildMacPath (&CDFreply.sfFile, CDFpath, TRUE); CDFtext[0] = strlen (CDFpath); strcpyX ((char *) &CDFtext[1], CDFpath, 255); SetIText ((Handle) controlHs[CDFTEXTin], CDFtext); } SetCursor (&(qd.arrow)); break; } /************************************************************************ * Check boxes. ************************************************************************/ case BROWSEin: case FORMATin: case INFOin: case WARNin: case ERRORin: case NEGZin: case PROMPTin: case STATSin: case gWITHin: case vWITHin: SetCtlValue (controlHs[itemN], BOO(GetCtlValue(controlHs[itemN]),0,1)); break; /************************************************************************ * Radio buttons. ************************************************************************/ case ZMODEinBASE+0: case ZMODEinBASE+1: case ZMODEinBASE+2: for (i = 0; i < 3; i++) SetCtlValue (controlHs[ZMODEinBASE+i], 0); SetCtlValue (controlHs[itemN], 1); break; } } } #endif