/****************************************************************************** * * NSSDC/CDF CDFexport. * * Version 1.2e, 14-Dec-97, Hughes STX. * * Modification history: * * V1.0 13-Sep-95, J Love Original version. * V1.0a 28-Sep-95, J Love Macintosh dialog filtering. Outline default * button. * V1.1 9-Sep-96, J Love CDF V2.6. * V1.2 15-Nov-96, J Love Added `simple' environment and batch mode. * V1.2a 15-Jan-97, J Love Added prompts for settings file (when saving * and restoring). Added `help' qualifier. * V1.2b 21-Feb-97, J Love Removed RICE. * V1.2c 30-Mar-97, J Love Allow FieldWindow fields to exceed their * on-screen width. * V1.2d 16-Nov-97, J Love Windows NT/Visual C++. * V1.2e 14-Dec-97, J Love Added ALPHAVMSi encoding. * V1.3 03-May-06, M Liu Added checksum option for the files. * V1.4 13-Oct-06, M Liu Changed to allow upper and lower case CDF * name to be used on win32. * ******************************************************************************/ #define CDFXP #include "cdfxp.h" /****************************************************************************** * 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 /****************************************************************************** * Main. ******************************************************************************/ #if !defined(win32) MAIN { Logical success = TRUE; strcpyX (pgmName, "CDFexport", MAX_PROGRAM_NAME_LEN); #if defined(mac) MacExecuteFSI (ExportCDFs, ExportQOPs); #else success = ExportCDFs (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 /****************************************************************************** * ExportCDFs. ******************************************************************************/ Logical ExportCDFs (argC, argV) int argC; char *argV[]; { static char CDFspec[DU_MAX_PATH_LEN+1] = CURRENTDIRECTORY; long zMode = BOO(DEFAULTsimpleEXPORT,DEFAULTzModeSIMPLE,DEFAULTzModeEXPORT); Logical negToPosFp0 = DEFAULT_NEGtoPOSfp0; Logical prompt = BOO(DEFAULTsimpleEXPORT,DEFAULTpromptSIMPLE, DEFAULTpromptEXPORT); /**************************************************************************** * Set defaults based on simple mode. ****************************************************************************/ OptDefaults (); /**************************************************************************** * Scan parameters/options/qualifiers. ****************************************************************************/ switch (argC) { case 1: if (!prompt) { create_pasteboard (); set_cursor_mode (CURSORoff); OnlineHelpWindow ("cdfxp.ilh", OLHhelpID); delete_pasteboard (ERASE); set_cursor_mode (CURSORon); return TRUE; } break; default: { QOP *qop; static char *validQuals[] = { "initial", "prompt", "noprompt", "cache", "zmode", "neg2posfp0", "noneg2posfp0", "report", "statistics", "nostatistics", "about", "simple", "nosimple", "cdf", "text", "settings", "batch", "help", NULL }; static int optRequired[] = { TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, 0 }; static char *reportTokens[] = { "errors", "warnings", "informationals" }; Logical qopError = FALSE; /************************************************************************ * Parse qualifiers, options, and parameters (QOPs). ************************************************************************/ 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; } /************************************************************************ * Check for `help' qualifier. ************************************************************************/ if (qop->qualEntered[HELPqual]) { create_pasteboard (); set_cursor_mode (CURSORoff); OnlineHelpWindow ("cdfxp.ilh", OLHhelpID); delete_pasteboard (ERASE); set_cursor_mode (CURSORon); cdf_FreeMemory (qop, FatalError); return TRUE; } /************************************************************************ * Check for `simple' qualifier. ************************************************************************/ qopError = qopError | !TFqualifier(qop,&simpleMode,SIMPLEqual, NOSIMPLEqual,DEFAULTsimpleEXPORT, "simple"); /************************************************************************ * Set some defaults based on simple mode. The other defaults will be * set as the remaining qualifiers are checked. ************************************************************************/ strcpyX (settingsFile, BOO(simpleMode,"simple.set", "export.set"), DU_MAX_PATH_LEN); zMode = BOO(simpleMode,DEFAULTzModeSIMPLE,DEFAULTzModeEXPORT); OptDefaults (); /************************************************************************ * Check for the `prompt' qualifier. ************************************************************************/ qopError = qopError | !TFqualifier(qop,&prompt,PROMPTqual,NOPROMPTqual, BOO(simpleMode, DEFAULTpromptSIMPLE, DEFAULTpromptEXPORT),"prompt"); /************************************************************************ * Check for `batch' qualifier. * Note that the `batch' qualifier will negate the `prompt' qualifier. ************************************************************************/ if (qop->qualEntered[BATCHqual]) { static char *batchStrings[] = { "cdf", "text", NULL }; static int batches[] = { BATCHcdf, BATCHtext }; int match = FindUniqueMatch (qop->qualOpt[BATCHqual],batchStrings); switch (match) { case NOMATCH: DisplayError ("Unknown batch mode."); qopError = TRUE; break; case MATCHES: DisplayError ("Ambiguous batch mode."); qopError = TRUE; break; default: batchMode = batches[match]; prompt = FALSE; break; } } else batchMode = noBATCH; /************************************************************************ * Check for `neg2posfp0' and `statistics' qualifiers. ************************************************************************/ qopError = qopError | !TFqualifier(qop,&negToPosFp0,NEG2POSFP0qual, NONEG2POSFP0qual,DEFAULT_NEGtoPOSfp0, "neg2posfp0"); qopError = qopError | !TFqualifier(qop,&dumpStats,STATSqual,NOSTATSqual, DEFAULTstatsEXPORT,"statistics"); /************************************************************************ * Check for `cdf', `text', and `settings' qualifiers. ************************************************************************/ if (qop->qualEntered[CDFqual]) strcpyX (outputCDF, qop->qualOpt[CDFqual], CDF_PATHNAME_LEN); if (qop->qualEntered[TEXTqual]) strcpyX (outputText, qop->qualOpt[TEXTqual], DU_MAX_PATH_LEN); if (qop->qualEntered[SETTINGSqual]) strcpyX (settingsFile, qop->qualOpt[SETTINGSqual], DU_MAX_PATH_LEN); /************************************************************************ * Check for `cache' qualifier. ************************************************************************/ if (qop->qualEntered[CACHEqual]) { if (!ParseCacheSizes(qop->qualOpt[CACHEqual], &workingCache,&stageCache,&compressCache)) { DisplayError ("Illegal cache size/type."); qopError = TRUE; } } /*********************************************************************** * Check for `report' qualifier. ***********************************************************************/ if (qop->qualEntered[REPORTqual]) { if (!ParseOptionList(3,reportTokens, qop->qualOpt[REPORTqual],report)) { DisplayError ("Illegal list of `report' options."); qopError = TRUE; } } /************************************************************************ * Check for `zMode' qualifier. ************************************************************************/ if (qop->qualEntered[ZMODEqual]) { if (!strcmp(qop->qualOpt[ZMODEqual],"0")) zMode = zMODEoff; else if (!strcmp(qop->qualOpt[ZMODEqual],"1")) zMode = zMODEon1; else if (!strcmp(qop->qualOpt[ZMODEqual],"2")) zMode = zMODEon2; else { DisplayError ("Illegal zMode."); qopError = TRUE; } } /************************************************************************ * Check for `initial' qualifier. ************************************************************************/ if (qop->qualEntered[INITIALqual]) { char *option, *parenPtr, *commaPtr, *nextPtr; int which; static char *validOptions[] = { "format", "noformat", "filter", "nofilter", "fillval", "nofillval", "single", "multi", "host", "network", "epoch", "epoch1", "epoch2", "epoch3", "epochf", "epochx", "horizontal", "vertical", "record", "norecord", "indices", "noindices", "row", "column", "validmin", "novalidmin", "monoton", "nomonoton", "validmax", "novalidmax", "fills", "nofills", "exclusive", "noexclusive", "output", "nooutput", "delete", "nodelete", "preallocate", "nopreallocate", "heading", "noheading", NULL }; /********************************************************************** * If VMS-style QOPs, "remove" beginning and ending parenthesis. Also, * remove any white space in the list of options. **********************************************************************/ if (qop->qualOpt[INITIALqual][0] == '(') { option = &(qop->qualOpt[INITIALqual][1]); parenPtr = strchr (option, ')'); if (parenPtr != NULL) *parenPtr = NUL; } else option = qop->qualOpt[INITIALqual]; RemoveWhiteSpace (option); /********************************************************************** * Scan comma-separated list of options. **********************************************************************/ while (*option != NUL) { /******************************************************************** * Location the end of the current option. This will be either a * comma or a NUL (if the last option). Also set the pointer to the * next option. ********************************************************************/ commaPtr = strchr (option, ','); if (commaPtr != NULL) { *commaPtr = NUL; nextPtr = commaPtr + 1; } else nextPtr = option + strlen(option); /******************************************************************** * Validate/set the current option. ********************************************************************/ which = MatchOption (option, validOptions); switch (which) { case UNKNOWNopt: { char msg[MAX_MESSAGE_TEXT_LEN+1]; sprintf (msg, "Unknown `initial' option: \"%s\"", option); DisplayError (msg); qopError = TRUE; break; } case AMBIGUOUSopt: { char msg[MAX_MESSAGE_TEXT_LEN+1]; sprintf (msg, "Ambiguous `initial' option: \"%s\"", option); DisplayError (msg); qopError = TRUE; break; } case FILTERopt: case NOFILTERopt: case FILLSopt: case NOFILLSopt: case FILLVALopt: case NOFILLVALopt: case VALIDMINopt: case NOVALIDMINopt: case VALIDMAXopt: case NOVALIDMAXopt: case MONOTONopt: case NOMONOTONopt: case SINGLEopt: case MULTIopt: case HOSTopt: case NETWORKopt: case EXCLUSIVEopt: case NOEXCLUSIVEopt: case DELETEopt: case NODELETEopt: case PREALLOCATEopt: case NOPREALLOCATEopt: if (simpleMode) { char msg[MAX_MESSAGE_TEXT_LEN+1]; sprintf (msg, "Illegal `initial' option: \"%s\"", option); DisplayError (msg); qopError = TRUE; } else { switch (which) { case FILTERopt: opt.eachFilter = TRUE; break; case NOFILTERopt: opt.eachFilter = FALSE; break; case FILLSopt: opt.useFills = TRUE; break; case NOFILLSopt: opt.useFills = FALSE; break; case FILLVALopt: opt.useFILLVAL = TRUE; break; case NOFILLVALopt: opt.useFILLVAL = FALSE; break; case VALIDMINopt: opt.useVALIDMIN = TRUE; break; case NOVALIDMINopt: opt.useVALIDMIN = FALSE; break; case VALIDMAXopt: opt.useVALIDMAX = TRUE; break; case NOVALIDMAXopt: opt.useVALIDMAX = FALSE; break; case MONOTONopt: opt.useMONOTON = TRUE; break; case NOMONOTONopt: opt.useMONOTON = FALSE; break; case SINGLEopt: opt.singleFile = TRUE; break; case MULTIopt: opt.singleFile = FALSE; break; case HOSTopt: opt.encoding = HOST_ENCODING; break; case NETWORKopt: opt.encoding = NETWORK_ENCODING; break; case EXCLUSIVEopt: opt.exclusive = TRUE; break; case NOEXCLUSIVEopt: opt.exclusive = FALSE; break; case DELETEopt: opt.deleteExisting = TRUE; break; case NODELETEopt: opt.deleteExisting = FALSE; break; case PREALLOCATEopt: opt.preAllocate = TRUE; break; case NOPREALLOCATEopt: opt.preAllocate = FALSE; break; } } break; case FORMATopt: opt.useFORMAT = TRUE; break; case NOFORMATopt: opt.useFORMAT = FALSE; break; case EPOCHopt: opt.epochStyle = EPOCH0_STYLE; break; case EPOCH1opt: opt.epochStyle = EPOCH1_STYLE; break; case EPOCH2opt: opt.epochStyle = EPOCH2_STYLE; break; case EPOCH3opt: opt.epochStyle = EPOCH3_STYLE; break; case EPOCHFopt: opt.epochStyle = EPOCHf_STYLE; break; case EPOCHXopt: opt.epochStyle = EPOCHx_STYLE; break; case HORIZONTALopt: opt.horizontalMode = TRUE; break; case VERTICALopt: opt.horizontalMode = FALSE; break; case RECORDopt: opt.showRecord = TRUE; break; case NORECORDopt: opt.showRecord = FALSE; break; case INDICESopt: opt.showIndices = TRUE; break; case NOINDICESopt: opt.showIndices = FALSE; break; case ROWopt: opt.majority = ROW_MAJOR; break; case COLUMNopt: opt.majority = COLUMN_MAJOR; break; case OUTPUTopt: opt.outputItem = TRUE; break; case NOOUTPUTopt: opt.outputItem = FALSE; break; case HEADINGopt: opt.textHeading = TRUE; break; case NOHEADINGopt: opt.textHeading = FALSE; break; } /******************************************************************** * Move to the next option. ********************************************************************/ option = nextPtr; } } /************************************************************************ * Check for a parameter (the CDF[s]). ************************************************************************/ switch (qop->Nparms) { case 0: if (!prompt) { DisplayError ("Missing parameter [CDF(s) specification]."); qopError = TRUE; } break; case 1: strcpyX (CDFspec, qop->parms[CDFparm], DU_MAX_PATH_LEN); break; default: DisplayError ("Too many parameters."); qopError = TRUE; } /************************************************************************ * Free QOP memory and return if an error was detected. ************************************************************************/ cdf_FreeMemory (qop, FatalError); if (qopError) return FALSE; break; } } /**************************************************************************** * Depending on batch mode... ****************************************************************************/ if (!BATCH(batchMode)) { /************************************************************************** * Initialize screen. **************************************************************************/ create_pasteboard (); set_cursor_mode (CURSORoff); /************************************************************************** * Export from CDFs until the cows come home. **************************************************************************/ CDFexportMenu (CDFspec, prompt, zMode, negToPosFp0); /************************************************************************** * Cleanup screen and return. **************************************************************************/ delete_pasteboard (ERASE); set_cursor_mode (CURSORon); } else { /************************************************************************** * Batch mode... **************************************************************************/ CDFid id; CDFstatus status; Logical noMoreAccess = FALSE; /************************************************************************** * Validate. **************************************************************************/ if (IsDir(CDFspec) || IsWild(CDFspec)) { DisplayError ("A single CDF must be specified in batch mode."); return FALSE; } /************************************************************************** * Open the CDF. **************************************************************************/ status = CDFlib (OPEN_, CDF_, CDFspec, &id, NULL_); DisplayStatus (status, "opening CDF"); if (StatusBAD(status)) return FALSE; /************************************************************************** * Set CDF modes and cache sizes. **************************************************************************/ status = CDFlib (SELECT_, CDF_READONLY_MODE_, READONLYon, CDF_zMODE_, zMode, CDF_CACHESIZE_, workingCache, STAGE_CACHESIZE_, stageCache, COMPRESS_CACHESIZE_, compressCache, CDF_NEGtoPOSfp0_MODE_, BOO(negToPosFp0, NEGtoPOSfp0on, NEGtoPOSfp0off), NULL_); DisplayStatus (status, "setting CDF modes"); if (StatusBAD(status)) { CDFclose (id); return FALSE; } /************************************************************************** * Load the CDF. **************************************************************************/ if (!LoadCDF()) { CDFclose (id); FreeItems (); return FALSE; } /************************************************************************** * Load settings file. **************************************************************************/ RestoreSettings (); /************************************************************************** * Generate CDF/listing. **************************************************************************/ switch (batchMode) { case BATCHcdf: if (!ToCDF(id)) noMoreAccess = TRUE; break; case BATCHtext: if (!BOO(opt.horizontalMode,ToFileHori(), ToFileVert())) noMoreAccess = TRUE; break; } /************************************************************************** * Close CDF. **************************************************************************/ if (dumpStats && !noMoreAccess) { vSTATS vStatsDotCDF, vStatsStage, vStatsCompress; char temp1[MAX_SCREENLINE_LEN+1], temp2[MAX_SCREENLINE_LEN+1], temp3[MAX_SCREENLINE_LEN+1]; status = CDFlib (CLOSE_, CDFwithSTATS_, &vStatsDotCDF, &vStatsStage, &vStatsCompress, NULL_); DisplayStatus (status, "closing CDF"); if (vStatsDotCDF.maxBuffers > 0) { BuildStatistics ("input CDF DotCDF file", &vStatsDotCDF, temp1, temp2, temp3); printf ("%s\n%s\n%s\n", temp1, temp2, temp3); } if (vStatsStage.maxBuffers > 0) { BuildStatistics ("input CDF staging file", &vStatsStage, temp1, temp2, temp3); printf ("%s\n%s\n%s\n", temp1, temp2, temp3); } if (vStatsCompress.maxBuffers > 0) { BuildStatistics ("input CDF compression scratch file", &vStatsCompress, temp1, temp2, temp3); printf ("%s\n%s\n%s\n", temp1, temp2, temp3); } } else{ status = CDFlib (CLOSE_, CDF_, NULL_); DisplayStatus (status, "closing CDF"); } /************************************************************************** * Free memory. **************************************************************************/ FreeItems (); } return TRUE; } /****************************************************************************** * CDFexportMenu. ******************************************************************************/ void CDFexportMenu (iniSpec, prompt, zMode, negToPosFp0) char *iniSpec; /* Initial specification. */ Logical prompt; /* Was the `prompt' qualifier specified? */ long zMode; /* zMode to use. */ Logical negToPosFp0; /* TRUE if -0.0 should be converted to 0.0. */ { char path[CDFfieldMAX+1]; static Logical first = TRUE; /**************************************************************************** * CDFwindow definitions. ****************************************************************************/ static char *cdfLabel[2] = { " CDFexport ", " CDFexport (SimpleMode) "}; AOSs2A (cdfLines, "CDF(s): ", BLANKs78) AOSs1 (cdfFields, BLANKs255) static int cdfLineNs[] = { CDFfieldLINEn }; static int cdfCols[] = { CDFfieldCOLn }; static int cdfLens[] = { CDFfieldLEN }; static int cdfMaxs[] = { CDFfieldMAX }; static int cdfExits[] = { ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI, NUL }; static struct FieldWindowStruct FWcdf_ = { 0, 0, SCREEN_WIDTH, NULL, 0, NULL, 2, cdfLines, cdfFields, 1, cdfLineNs, cdfCols, cdfLens, cdfMaxs, 2, 0, NULL, cdfExits, REFRESHkey_FSI, FALSE, NUL, NUL, INSERTorOVERkey_FSI }; /**************************************************************************** * SelectionWindow definitions. ****************************************************************************/ static char *varLabel[2] = { " SelectionWindow, part 0 ", " SelectionWindow " }; static char *varHeader[] = { "" }; static struct ItemWindowStruct IWsel_ = { 4, 0, SCREEN_WIDTH, NULL, 1, varHeader, 0, NULL, 0, NULL, NULL, NULL, 9, 0, NULL, NULL, REFRESHkey_FSI, TRUE, NSkey_FSI, PSkey_FSI }; /**************************************************************************** * KeyWindow definitions. ****************************************************************************/ static char keyDefsBlank[] = "\n\n"; static char keyDefsPrompt[] = { "Open: ________ Help: ________ Exit: ________\n\n" }; static struct EditWindowStruct EWkey_ = { " KeyDefinitions ", 17, 0, SCREEN_WIDTH, 0, NULL, keyDefsBlank, 2, 0, NULL, FALSE, TRUE, NULL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL }; /**************************************************************************** * MessageWindow definitions. ****************************************************************************/ static char msgLines[] = BLANKs78; static int msgExits[] = { NUL }; static struct EditWindowStruct EWmsg_ = { " MessageBuffer ", 21, 0, SCREEN_WIDTH, 0, NULL, msgLines, 1, 0, NULL, FALSE, TRUE, msgExits, REFRESHkey_FSI, NUL, NUL, NUL, NUL, NUL, NUL, NUL, NUL }; /**************************************************************************** * Initialize global variables. ****************************************************************************/ itemHead = NULL; FWcdf = &FWcdf_; IWsel = &IWsel_; EWkey = &EWkey_; EWmsg = &EWmsg_; /**************************************************************************** * Initialize CDFwindow and encode key definitions. ****************************************************************************/ strcpyX (FWcdf->fields[0], iniSpec, CDFfieldMAX); if (first) { char *p1 = keyDefsPrompt; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); FWcdf->label = cdfLabel[BOO(simpleMode,1,0)]; IWsel->label = varLabel[BOO(simpleMode,1,0)]; first = FALSE; } /**************************************************************************** * Display menu widgets. ****************************************************************************/ FieldWindow (NEWfw, FWcdf, 0, LogicalTRUE); ItemWindow (NEWiw, IWsel, 0); EditWindow (NEWew, EWkey, LogicalTRUE); EditWindow (NEWew, EWmsg, LogicalTRUE); /**************************************************************************** * Determine/export CDF. ****************************************************************************/ if (prompt) { NEWkeyDEFS (EWkey, keyDefsPrompt, batchMode) FieldWindow (READfw, FWcdf); } else FWcdf->key = ENTERkey_FSI; for (;;) { switch (FWcdf->key) { case ENTERkey_FSI: strcpyX (path, FWcdf->fields[0], CDFfieldMAX); if (IsCDF(path)) { ExportCDF (path, zMode, negToPosFp0); MakeNUL (FWcdf->fLines[CDFvarsRecsLINEn]); FieldWindow (UPDATEfw, FWcdf, 0, LogicalTRUE); IWsel->label = varLabel[BOO(simpleMode,1,0)]; IWsel->hLines = varHeader; ItemWindow (UPDATEiw, IWsel, 0); } else if (IsDir(path) || IsWild(path)) ExportCDFsSpec (path, zMode, negToPosFp0, varLabel[BOO(simpleMode,1,0)], varHeader); else DisplayMessage ("No CDFs found for specification.", BEEPWAIT1); break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", CDFhelpID); break; case EXITkey_FSI: FieldWindow (DELETEfw, FWcdf); ItemWindow (DELETEiw, IWsel); EditWindow (DELETEew, EWkey); EditWindow (DELETEew, EWmsg); return; } NEWkeyDEFS (EWkey, keyDefsPrompt, batchMode) FieldWindow (READfw, FWcdf); } } /****************************************************************************** * ExportCDFsSpec. ******************************************************************************/ void ExportCDFsSpec (path, zMode, negToPosFp0, varLabel0, varHeader0) char *path; long zMode; Logical negToPosFp0; char *varLabel0; char *varHeader0[]; { Logical first = TRUE; int nCDFs, CDFn; char **dirS, **CDFs; static int exitCDFs[] = { ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI, NUL }; static struct ItemWindowStruct IWcdfs = { 1, 79 - CDFnameLEN - 2, CDFnameLEN + 2, " Select a CDF ", 0, NULL, 0, NULL, 0, NULL, NULL, NULL, 13, 0, NULL, exitCDFs, REFRESHkey_FSI, TRUE, NUL, NUL }; static char keyDefs[] = { "Open: ________ Help: ________ Exit: ________\n\n" }; /**************************************************************************** * Encode key definitions first time. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); first = FALSE; } /**************************************************************************** * Get directory listing of CDFs. ****************************************************************************/ nCDFs = CDFdirList (path, &dirS, &CDFs); if (nCDFs < 1) { DisplayMessage ("No CDFs found for specification.", BEEPWAIT1); return; } /**************************************************************************** * Allocate/load CDFs. ****************************************************************************/ AllocIW (&IWcdfs, nCDFs, nCDFs, IWcdfs.nColsTotal - 2, FatalError); for (CDFn = 0; CDFn < nCDFs; CDFn++) { strcpyX (IWcdfs.iLines[CDFn], CDFs[CDFn], IWcdfs.nColsTotal - 2); IWcdfs.iLineNs[CDFn] = CDFn; IWcdfs.iCols[CDFn] = 0; IWcdfs.iLens[CDFn] = CDFnameLEN; } /**************************************************************************** * Select a CDF. ****************************************************************************/ ItemWindow (NEWiw, &IWcdfs, 0); NEWkeyDEFS (EWkey, keyDefs, batchMode) for (;;) { ItemWindow (READiw, &IWcdfs); switch (IWcdfs.key) { case ENTERkey_FSI: { char pathX[CDF_PATHNAME_LEN+1]; strcpyX (pathX, dirS[IWcdfs.itemN], CDF_PATHNAME_LEN); AppendToDir (pathX, CDFs[IWcdfs.itemN]); ItemWindow (UNDISPLAYiw, &IWcdfs); ExportCDF (pathX, zMode, negToPosFp0); strcpyX (FWcdf->fields[0], path, CDFfieldMAX); MakeNUL (FWcdf->fLines[CDFvarsRecsLINEn]); FieldWindow (UPDATEfw, FWcdf, 0, LogicalTRUE); IWsel->label = varLabel0; IWsel->hLines = varHeader0; ItemWindow (UPDATEiw, IWsel, 0); NEWkeyDEFS (EWkey, keyDefs, batchMode) ItemWindow (REDISPLAYiw, &IWcdfs); break; } case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", CDFShelpID); break; case EXITkey_FSI: ItemWindow (DELETEiw, &IWcdfs); FreeIW (&IWcdfs, FatalError); cdf_FreeMemory (CDFs, FatalError); cdf_FreeMemory (dirS, FatalError); return; } } } /****************************************************************************** * ExportCDF. ******************************************************************************/ void ExportCDF (path, zMode, negToPosFp0) char *path; long zMode; Logical negToPosFp0; { CDFid id; CDFstatus status; Logical noMoreAccess = FALSE; static char keyDefsBlank[] = "\n\n"; /**************************************************************************** * Erase key definitions while loading. ****************************************************************************/ NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) /**************************************************************************** * Open CDF. ****************************************************************************/ DisplayMessage ("Opening CDF...", NOWAIT); status = CDFlib (OPEN_, CDF_, path, &id, NULL_); DisplayStatus (status, "opening CDF"); if (StatusBAD(status)) return; /**************************************************************************** * Select CDF modes, etc. ****************************************************************************/ status = CDFlib (SELECT_, CDF_READONLY_MODE_, READONLYon, CDF_zMODE_, zMode, CDF_CACHESIZE_, workingCache, STAGE_CACHESIZE_, stageCache, COMPRESS_CACHESIZE_, compressCache, CDF_NEGtoPOSfp0_MODE_, BOO(negToPosFp0, NEGtoPOSfp0on, NEGtoPOSfp0off), NULL_); DisplayStatus (status, "setting CDF modes"); if (StatusBAD(status)) { CDFclose (id); return; } /**************************************************************************** * Inquire CDF and load/update widgets. ****************************************************************************/ DisplayMessage ("Loading CDF...", NOWAIT); if (!LoadCDF()) { CDFclose (id); FreeItems (); return; } LoadCDFwindow (path); FieldWindow (UPDATEfw, FWcdf, 0, LogicalTRUE); /**************************************************************************** * Process keystrokes. ****************************************************************************/ DisplayMessage ("", NOWAIT); if (simpleMode) SelectionWindow (&noMoreAccess); else { for (;;) { if (!SelectionWindow1(&noMoreAccess)) break; if (!SelectionWindow2(&noMoreAccess)) break; if (!SelectionWindow3(&noMoreAccess)) break; if (!SelectionWindow4(&noMoreAccess)) break; } } if (noMoreAccess) { NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) InfoWindow ("Access to this CDF has been aborted.", NULL, NULL, TRUE, TRUE, 1); } /**************************************************************************** * Exit this CDF. ****************************************************************************/ FreeItems (); FreeIW (IWsel, FatalError); if (dumpStats && !noMoreAccess) { vSTATS vStatsDotCDF, vStatsStage, vStatsCompress; char temp1[MAX_SCREENLINE_LEN+1], temp2[MAX_SCREENLINE_LEN+1], temp3[MAX_SCREENLINE_LEN+1]; status = CDFlib (CLOSE_, CDFwithSTATS_, &vStatsDotCDF, &vStatsStage, &vStatsCompress, NULL_); DisplayStatus (status, "closing CDF"); if (vStatsDotCDF.maxBuffers > 0) { BuildStatistics ("input CDF DotCDF file", &vStatsDotCDF, temp1, temp2, temp3); InfoWindow (temp1, temp2, temp3, FALSE, FALSE, 0); } if (vStatsStage.maxBuffers > 0) { BuildStatistics ("input CDF staging file", &vStatsStage, temp1, temp2, temp3); InfoWindow (temp1, temp2, temp3, FALSE, FALSE, 0); } if (vStatsCompress.maxBuffers > 0) { BuildStatistics ("input CDF compression scratch file", &vStatsCompress, temp1, temp2, temp3); InfoWindow (temp1, temp2, temp3, FALSE, FALSE, 0); } } else{ status = CDFlib (CLOSE_, CDF_, NULL_); DisplayStatus (status, "closing CDF"); } return; } /****************************************************************************** * LoadCDFwindow. ******************************************************************************/ void LoadCDFwindow (path) char *path; { if (path != NULL) strcpyX (FWcdf->fields[0], path, CDFfieldMAX); if (simpleMode) sprintf (FWcdf->fLines[CDFvarsRecsLINEn], "Variables: %ld, Records: %ld", (long) (NrVars + NzVars), (long) (MAXIMUM(rMaxRec,zMaxRec) + 1)); else sprintf (FWcdf->fLines[CDFvarsRecsLINEn], "Variables: %ldr/%ldz, Records: %ldr/%ldz, Compression: %s, Checksum: %s", NrVars, NzVars, (long) (rMaxRec + 1), (long) (zMaxRec + 1), CompressionToken(CDFcType,CDFcParms), ChecksumToken(CDFchecksum)); return; } /****************************************************************************** * LoadCDF. * * Some of the values loaded aren't really necessary if `simple' mode has been * selected. ******************************************************************************/ Logical LoadCDF () { CDFstatus status; char varName[CDF_VAR_NAME_LEN+1]; long eDataType, eNumElems, cPct, sArraysPct; int varX, lineL = SCREEN_WIDTH - 2, nVars, dimN; struct ItemStruct *Item, *itemTail = NULL; static char readingCDF[] = "reading input CDF"; /**************************************************************************** * Initialize. ****************************************************************************/ nItems = 0; /**************************************************************************** * Inquire/check number of variables. ****************************************************************************/ status = CDFlib (GET_, CDF_NUMrVARS_, &NrVars, CDF_NUMzVARS_, &NzVars, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; nVars = (int) (NrVars + NzVars); if (nVars == 0) { DisplayMessage ("Error loading CDF.", BEEPWAIT1); DisplayMessage ("CDF contains no variables.", BEEPWAIT1); return FALSE; } /**************************************************************************** * Inquire/check number of records. ****************************************************************************/ status = CDFlib (GET_, rVARs_MAXREC_, &rMaxRec, zVARs_MAXREC_, &zMaxRec, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; if (MAXIMUM(rMaxRec,zMaxRec) < 0) { DisplayMessage ("Error loading CDF.", BEEPWAIT1); DisplayMessage ("CDF contains no records.", BEEPWAIT1); return FALSE; } /**************************************************************************** * Load CDF compression. ****************************************************************************/ status = CDFlib (GET_, CDF_COMPRESSION_, &CDFcType, CDFcParms, &cPct, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; /**************************************************************************** * Load CDF checksum. ****************************************************************************/ status = CDFlib (GET_, CDF_CHECKSUM_, &CDFchecksum, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; /**************************************************************************** * Load records/indices. ****************************************************************************/ if (opt.showRecord) { Item = (struct ItemStruct *) cdf_AllocateMemory (sizeof(struct ItemStruct), FatalError); Item->type = RECORDt; Item->width = MIN_RECORD_WIDTH; Item->outputSetting = opt.outputItem; Item->filterSetting = opt.eachFilter; Item->inclusive = TRUE; Item->nextItem = NULL; Item->Record = (struct RecordStruct *) cdf_AllocateMemory (sizeof(struct RecordStruct), FatalError); Item->Record->min = NOminMax; Item->Record->max = NOminMax; itemHead = Item; itemTail = Item; nItems++; } if (opt.showIndices) { Item = (struct ItemStruct *) cdf_AllocateMemory (sizeof(struct ItemStruct), FatalError); Item->type = INDICESt; Item->width = MIN_INDICES_WIDTH; Item->outputSetting = opt.outputItem; Item->filterSetting = opt.eachFilter; Item->inclusive = TRUE; Item->nextItem = NULL; Item->Indices = (struct IndicesStruct *) cdf_AllocateMemory (sizeof(struct IndicesStruct), FatalError); Item->Indices->minNumDims = NOminMax; Item->Indices->maxNumDims = NOminMax; if (itemHead == NULL) itemHead = Item; else itemTail->nextItem = Item; itemTail = Item; nItems++; } /**************************************************************************** * Load variables. ****************************************************************************/ for (varX = 0; varX < nVars; varX++) { /************************************************************************* * Allocate a variable structure and an Item structure and place on linked * list. *************************************************************************/ Item = (struct ItemStruct *) cdf_AllocateMemory (sizeof(struct ItemStruct), FatalError); Item->type = VARIABLEt; Item->outputSetting = opt.outputItem; Item->filterSetting = FALSE; /* Reset below... */ Item->inclusive = TRUE; Item->Var = (struct VarStruct *) cdf_AllocateMemory (sizeof(struct VarStruct), FatalError); Item->nextItem = NULL; if (itemHead == NULL) itemHead = Item; else itemTail->nextItem = Item; itemTail = Item; /************************************************************************* * Initialize variable structure. *************************************************************************/ Item->Var->zVar = (varX >= NrVars); Item->Var->varN = BOO(varX >= NrVars,varX - NrVars,varX); Item->Var->min = NULL; Item->Var->max = NULL; Item->Var->format = NULL; Item->Var->fill = NULL; Item->Var->pad = NULL; Item->Var->value = NULL; /************************************************************************* * Load variable dimensionality, variances, data type/number of elements, * maximum record written, sparseness, compression, and blocking factor. *************************************************************************/ status = CDFlib (SELECT_, BOO(Item->Var->zVar, zVAR_,rVAR_), Item->Var->varN, GET_, BOO(Item->Var->zVar, zVAR_NUMDIMS_, rVARs_NUMDIMS_), &(Item->Var->numDims), BOO(Item->Var->zVar, zVAR_DIMSIZES_, rVARs_DIMSIZES_), Item->Var->dimSizes, BOO(Item->Var->zVar, zVAR_DATATYPE_, rVAR_DATATYPE_), &(Item->Var->dataType), BOO(Item->Var->zVar, zVAR_NUMELEMS_, rVAR_NUMELEMS_), &(Item->Var->numElems), BOO(Item->Var->zVar, zVAR_MAXREC_, rVAR_MAXREC_), &(Item->Var->maxRec), BOO(Item->Var->zVar, zVAR_RECVARY_, rVAR_RECVARY_), &(Item->Var->recVary), BOO(Item->Var->zVar, zVAR_DIMVARYS_, rVAR_DIMVARYS_), Item->Var->dimVarys, BOO(Item->Var->zVar, zVAR_SPARSERECORDS_, rVAR_SPARSERECORDS_), &(Item->Var->sRecordsType), BOO(Item->Var->zVar, zVAR_SPARSEARRAYS_, rVAR_SPARSEARRAYS_), &(Item->Var->sArraysType), Item->Var->sArraysParms, &sArraysPct, BOO(Item->Var->zVar, zVAR_COMPRESSION_, rVAR_COMPRESSION_), &(Item->Var->cType), Item->Var->cParms, &cPct, BOO(Item->Var->zVar, zVAR_BLOCKINGFACTOR_, rVAR_BLOCKINGFACTOR_), &(Item->Var->blocking), NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; /************************************************************************* * Load reserve percentage. *************************************************************************/ if (Item->Var->cType == NO_COMPRESSION) Item->Var->reserve = NA_RESERVE; else { status = CDFlib (CONFIRM_, BOO(Item->Var->zVar, zVAR_RESERVEPERCENT_, rVAR_RESERVEPERCENT_), &(Item->Var->reserve), NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; } /************************************************************************* * Calculate the number of values per variable record (conceptual) and * the number of bytes per value. *************************************************************************/ Item->Var->nRecordValues = 1; for (dimN = 0; dimN < Item->Var->numDims; dimN++) { Item->Var->nRecordValues *= Item->Var->dimSizes[dimN]; } Item->Var->nValueBytes = (size_t) (CDFelemSize(Item->Var->dataType) * Item->Var->numElems); /************************************************************************* * Load variable name. *************************************************************************/ status = CDFlib (GET_, BOO(Item->Var->zVar, zVAR_NAME_,rVAR_NAME_), varName, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; RemoveTrailingBlanks (varName); Item->Var->name = (char *) cdf_AllocateMemory (strlen(varName) + 1, FatalError); strcpyX (Item->Var->name, varName, 0); /************************************************************************* * Load VALIDMIN entry. *************************************************************************/ if (opt.useVALIDMIN) { status = CDFlib (SELECT_, ATTR_NAME_, "VALIDMIN", BOO(Item->Var->zVar, zENTRY_,rENTRY_), Item->Var->varN, GET_, BOO(Item->Var->zVar, zENTRY_DATATYPE_, rENTRY_DATATYPE_), &eDataType, BOO(Item->Var->zVar, zENTRY_NUMELEMS_, rENTRY_NUMELEMS_), &eNumElems, NULL_); switch (status) { case CDF_OK: { size_t nBytesE = (size_t) (CDFelemSize(eDataType) * eNumElems); void *buffer = cdf_AllocateMemory (nBytesE, FatalError); status = CDFlib (GET_, BOO(Item->Var->zVar, zENTRY_DATA_,rENTRY_DATA_), buffer, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) { cdf_FreeMemory (buffer, FatalError); return FALSE; } Item->Var->min = cdf_AllocateMemory (Item->Var->nValueBytes, FatalError); ConvertDataType (eDataType, eNumElems, buffer, Item->Var->dataType, Item->Var->numElems, Item->Var->min); cdf_FreeMemory (buffer, FatalError); Item->filterSetting = opt.eachFilter; break; } case NO_SUCH_ATTR: case NO_SUCH_ENTRY: break; default: DisplayStatus (status, readingCDF); return FALSE; } } /************************************************************************* * Load VALIDMAX. *************************************************************************/ if (opt.useVALIDMAX) { status = CDFlib (SELECT_, ATTR_NAME_, "VALIDMAX", BOO(Item->Var->zVar, zENTRY_,rENTRY_), Item->Var->varN, GET_, BOO(Item->Var->zVar, zENTRY_DATATYPE_, rENTRY_DATATYPE_), &eDataType, BOO(Item->Var->zVar, zENTRY_NUMELEMS_, rENTRY_NUMELEMS_), &eNumElems, NULL_); switch (status) { case CDF_OK: { size_t nBytesE = (size_t) (CDFelemSize(eDataType) * eNumElems); void *buffer = cdf_AllocateMemory (nBytesE, FatalError); status = CDFlib (GET_, BOO(Item->Var->zVar, zENTRY_DATA_,rENTRY_DATA_), buffer, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) { cdf_FreeMemory (buffer, FatalError); return FALSE; } Item->Var->max = cdf_AllocateMemory (Item->Var->nValueBytes, FatalError); ConvertDataType (eDataType, eNumElems, buffer, Item->Var->dataType, Item->Var->numElems, Item->Var->max); cdf_FreeMemory (buffer, FatalError); Item->filterSetting = opt.eachFilter; break; } case NO_SUCH_ATTR: case NO_SUCH_ENTRY: break; default: DisplayStatus (status, readingCDF); return FALSE; } } /************************************************************************* * Validate VALIDMIN/VALIDMAX entries. *************************************************************************/ if (Item->Var->min != NULL && Item->Var->max != NULL) { if (GTx(Item->Var->min,Item->Var->max, Item->Var->dataType,Item->Var->numElems)) { static char msg[SCREEN_WIDTH+CDF_VAR_NAME_LEN+1]; sprintf (msg, "VALIDMIN > VALIDMAX for variable `%s' (both ignored).", Item->Var->name); DisplayMessage (msg, NOBEEPWAIT1); cdf_FreeMemory (Item->Var->min, FatalError); cdf_FreeMemory (Item->Var->max, FatalError); Item->Var->min = NULL; Item->Var->max = NULL; Item->filterSetting = FALSE; } } /************************************************************************* * Load FILLVAL. *************************************************************************/ if (opt.useFILLVAL) { status = CDFlib (SELECT_, ATTR_NAME_, "FILLVAL", BOO(Item->Var->zVar, zENTRY_,rENTRY_), Item->Var->varN, GET_, BOO(Item->Var->zVar, zENTRY_DATATYPE_, rENTRY_DATATYPE_), &eDataType, BOO(Item->Var->zVar, zENTRY_NUMELEMS_, rENTRY_NUMELEMS_), &eNumElems, NULL_); switch (status) { case CDF_OK: { size_t nBytesE = (size_t) (CDFelemSize(eDataType) * eNumElems); void *buffer = cdf_AllocateMemory (nBytesE, FatalError); status = CDFlib (GET_, BOO(Item->Var->zVar, zENTRY_DATA_,rENTRY_DATA_), buffer, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) { cdf_FreeMemory (buffer, FatalError); return FALSE; } Item->Var->fill = cdf_AllocateMemory (Item->Var->nValueBytes, FatalError); ConvertDataType (eDataType, eNumElems, buffer, Item->Var->dataType, Item->Var->numElems, Item->Var->fill); cdf_FreeMemory (buffer, FatalError); break; } case NO_SUCH_ATTR: case NO_SUCH_ENTRY: break; default: DisplayStatus (status, readingCDF); return FALSE; } } /************************************************************************* * Load FORMAT entry. *************************************************************************/ if (opt.useFORMAT) { status = CDFlib (SELECT_, ATTR_NAME_, "FORMAT", BOO(Item->Var->zVar, zENTRY_,rENTRY_), Item->Var->varN, GET_, BOO(Item->Var->zVar, zENTRY_DATATYPE_, rENTRY_DATATYPE_), &eDataType, BOO(Item->Var->zVar, zENTRY_NUMELEMS_, rENTRY_NUMELEMS_), &eNumElems, NULL_); switch (status) { case CDF_OK: { if (STRINGdataType(eDataType)) { Item->Var->format = (char *) cdf_AllocateMemory ((size_t) eNumElems + 1, FatalError); status = CDFlib (GET_, BOO(Item->Var->zVar, zENTRY_DATA_, rENTRY_DATA_), Item->Var->format, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; (Item->Var->format)[(int)eNumElems] = NUL; RemoveWhiteSpace (Item->Var->format); } break; } case NO_SUCH_ATTR: case NO_SUCH_ENTRY: break; default: DisplayStatus (status, readingCDF); return FALSE; } } Item->width = VariableWidth(Item->Var); /************************************************************************* * Load monotonicity. *************************************************************************/ if (OneDimensionVaries(Item->Var)) { Item->Var->monotonic = UNKNOWNmono; if (opt.useMONOTON) { status = CDFlib (SELECT_, ATTR_NAME_, "MONOTON", BOO(Item->Var->zVar, zENTRY_,rENTRY_), Item->Var->varN, GET_, BOO(Item->Var->zVar, zENTRY_DATATYPE_, rENTRY_DATATYPE_), &eDataType, BOO(Item->Var->zVar, zENTRY_NUMELEMS_, rENTRY_NUMELEMS_), &eNumElems, NULL_); switch (status) { case CDF_OK: { size_t nBytes = (size_t) (CDFelemSize(eDataType) * eNumElems); char *buffer = (char *) cdf_AllocateMemory (nBytes + 1, FatalError); status = CDFlib (GET_, BOO(Item->Var->zVar, zENTRY_DATA_,rENTRY_DATA_), buffer, NULL_); DisplayStatus (status, readingCDF); if (StatusBAD(status)) { cdf_FreeMemory (buffer, FatalError); return FALSE; } if (STRINGdataType(eDataType)) { buffer[(int)eNumElems] = NUL; if (!strcmpITB(buffer,"INCREASE")) Item->Var->monotonic = INCREASEmono; else if (!strcmpITB(buffer,"DECREASE")) Item->Var->monotonic = DECREASEmono; else if (!strcmpITB(buffer,"FALSE")) { Item->Var->monotonic=FALSEmono; } } cdf_FreeMemory (buffer, FatalError); break; } case NO_SUCH_ATTR: case NO_SUCH_ENTRY: break; default: DisplayStatus (status, readingCDF); return FALSE; } } } else Item->Var->monotonic = NAmono; /************************************************************************* * Load pad value. *************************************************************************/ Item->Var->pad = cdf_AllocateMemory (Item->Var->nValueBytes, FatalError); status = CDFlib (GET_, BOO(Item->Var->zVar, zVAR_PADVALUE_, rVAR_PADVALUE_), Item->Var->pad, NULL_); if (status != NO_PADVALUE_SPECIFIED) DisplayStatus (status, readingCDF); if (StatusBAD(status)) return FALSE; /************************************************************************* * Allocate buffer for value(s) and set miscellaneous flags. *************************************************************************/ Item->Var->value = cdf_AllocateMemory (Item->Var->nValueBytes, FatalError); Item->Var->scalar = ScalarVariable (Item->Var); /************************************************************************* * Tally another line. *************************************************************************/ nItems++; } /**************************************************************************** * Inquire majority. ****************************************************************************/ status = CDFlib (GET_, CDF_MAJORITY_, &inMajority, NULL_); DisplayStatus (status, "inquiring CDF majority"); if (StatusBAD(status)) return FALSE; /**************************************************************************** * Allocate SelectionWindow unless in batch mode. ****************************************************************************/ if (!BATCH(batchMode)) { AllocIW (IWsel, nSELWINDOWcolsMAX * nItems, nItems, lineL, FatalError); } return TRUE; } /****************************************************************************** * LoadSelectionWindow. ******************************************************************************/ Logical LoadSelectionWindow (part) int part; { int itemN, lineN; char temp[MAXitemFieldLEN+1]; struct ItemStruct *Item; /**************************************************************************** * Load the requested part. ****************************************************************************/ switch (part) { /************************************************************************** * `Simple' mode. Name & output. **************************************************************************/ case PART_: for (Item = itemHead, lineN = 0; Item != NULL; Item = Item->nextItem, lineN++) { /********************************************************************* * Load item/variable name. *********************************************************************/ switch (Item->type) { case RECORDt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLENsimple, LEFT_JUSTIFY, dots); break; case INDICESt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLENsimple, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeString ((long) strlen(Item->Var->name), Item->Var->name, IWsel->iLines[lineN], -NAMEitemLENsimple, NAMEitemLENsimple); break; } itemN = nSELWINDOWcols_ * lineN; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = NAMEitemCOLnSIMPLE; IWsel->iLens[itemN] = NAMEitemLENsimple; /********************************************************************* * Load output. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); CatToString (IWsel->iLines[lineN], BOO(Item->outputSetting,"YES","no"), OUTPUTitemLEN, LEFT_JUSTIFY, dots); itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = OUTPUTitemCOLnSIMPLE; IWsel->iLens[itemN] = OUTPUTitemLENsimple; } IWsel->nItems = itemN + 1; break; /************************************************************************** * Part 1. Name, data specification, dimensionality, variances, output. **************************************************************************/ case PART1: for (Item = itemHead, lineN = 0; Item != NULL; Item = Item->nextItem, lineN++) { /********************************************************************* * Load item/variable name. *********************************************************************/ switch (Item->type) { case RECORDt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case INDICESt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeString ((long) strlen(Item->Var->name), Item->Var->name, IWsel->iLines[lineN], -NAMEitemLEN, NAMEitemLEN); break; } itemN = nSELWINDOWcols1 * lineN; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = NAMEitemCOLn; IWsel->iLens[itemN] = NAMEitemLEN; /********************************************************************* * Load data specification. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, SPECitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: sprintf (temp, "%s/%ld", DataTypeToken(Item->Var->dataType), Item->Var->numElems); CatToString (IWsel->iLines[lineN], temp, SPECitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = SPECitemCOLn; IWsel->iLens[itemN] = SPECitemLEN; /********************************************************************* * Load dimensionality. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, DIMENitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeDimensionality (temp, Item->Var->numDims, Item->Var->dimSizes); CatToString (IWsel->iLines[lineN], temp, DIMENitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = DIMENitemCOLn; IWsel->iLens[itemN] = DIMENitemLEN; /********************************************************************* * Load variances. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, VARYSitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeVariances (temp, Item->Var->recVary, Item->Var->numDims, Item->Var->dimVarys); CatToString (IWsel->iLines[lineN], temp, VARYSitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = VARYSitemCOLn; IWsel->iLens[itemN] = VARYSitemLEN; /********************************************************************* * Load output. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); CatToString (IWsel->iLines[lineN], BOO(Item->outputSetting,"YES","no"), OUTPUTitemLEN, LEFT_JUSTIFY, dots); itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = OUTPUTitemCOLn; IWsel->iLens[itemN] = OUTPUTitemLEN; } IWsel->nItems = itemN + 1; break; /************************************************************************** * Part 2. Name, minimum, maximum, filter. **************************************************************************/ case PART2: for (Item = itemHead, lineN = 0; Item != NULL; Item = Item->nextItem, lineN++) { /********************************************************************* * Load item/variable name. *********************************************************************/ switch (Item->type) { case RECORDt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case INDICESt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeString ((long) strlen(Item->Var->name), Item->Var->name, IWsel->iLines[lineN], -NAMEitemLEN, NAMEitemLEN); break; } itemN = nSELWINDOWcols2 * lineN; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = NAMEitemCOLn; IWsel->iLens[itemN] = NAMEitemLEN; /********************************************************************* * Load minimum value. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: if (Item->Record->min == NOminMax) MakeNUL (temp); else sprintf (temp, "%ld", Item->Record->min + 1); CatToString (IWsel->iLines[lineN], temp, MINitemLEN, LEFT_JUSTIFY, dots); break; case INDICESt: if (Item->Indices->minNumDims == NOminMax) CatNcharacters (IWsel->iLines[lineN], MINitemLEN, ' '); else { EncodeIndicesJustify (temp, Item->Indices->minNumDims, Item->Indices->minIndices, 0); CatToString (IWsel->iLines[lineN], temp, MINitemLEN, LEFT_JUSTIFY, dots); } break; case VARIABLEt: if (Item->Var->min != NULL) EncodeValuesFormat (Item->Var->dataType, Item->Var->numElems, Item->Var->min, EofS(IWsel->iLines[lineN]), NULL, -MINitemLEN, MINitemLEN, opt.epochStyle); else CatNcharacters (IWsel->iLines[lineN], MINitemLEN, ' '); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = MINitemCOLn; IWsel->iLens[itemN] = MINitemLEN; /********************************************************************* * Load maximum value. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: if (Item->Record->max == NOminMax) MakeNUL (temp); else sprintf (temp, "%ld", Item->Record->max + 1); CatToString (IWsel->iLines[lineN], temp, MAXitemLEN, LEFT_JUSTIFY, dots); break; case INDICESt: if (Item->Indices->maxNumDims == NOminMax) CatNcharacters (IWsel->iLines[lineN], MAXitemLEN, ' '); else { EncodeIndicesJustify (temp, Item->Indices->maxNumDims, Item->Indices->maxIndices, 0); CatToString (IWsel->iLines[lineN], temp, MAXitemLEN, LEFT_JUSTIFY, dots); } break; case VARIABLEt: if (Item->Var->max != NULL) EncodeValuesFormat (Item->Var->dataType, Item->Var->numElems, Item->Var->max, EofS(IWsel->iLines[lineN]), NULL, -MAXitemLEN, MAXitemLEN, opt.epochStyle); else CatNcharacters (IWsel->iLines[lineN], MAXitemLEN, ' '); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = MAXitemCOLn; IWsel->iLens[itemN] = MAXitemLEN; /********************************************************************* * Load filter. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); CatToString (IWsel->iLines[lineN], BOO(Item->filterSetting, BOO(opt.overallFilter, BOO(opt.exclusive, BOO(Item->inclusive,"YeS","yEs"),"YES"), BOO(opt.exclusive, BOO(Item->inclusive, "(YeS)","(yEs)"),"(YES)")), BOO(opt.overallFilter,"no","(no)")), FILTERitemLEN, LEFT_JUSTIFY, dots); itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = FILTERitemCOLn; IWsel->iLens[itemN] = FILTERitemLEN; } IWsel->nItems = itemN + 1; break; /************************************************************************** * Part 3. Name, fill value, monotonicity, format, width. **************************************************************************/ case PART3: for (Item = itemHead, lineN = 0; Item != NULL; Item = Item->nextItem, lineN++) { /********************************************************************* * Load item/variable name. *********************************************************************/ switch (Item->type) { case RECORDt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case INDICESt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeString ((long) strlen(Item->Var->name), Item->Var->name, IWsel->iLines[lineN], -NAMEitemLEN, NAMEitemLEN); break; } itemN = nSELWINDOWcols3 * lineN; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = NAMEitemCOLn; IWsel->iLens[itemN] = NAMEitemLEN; /********************************************************************* * Load fill value. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, FILLitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: if (Item->Var->fill != NULL) { char temp[FILLitemLEN+1]; MakeNUL (temp); if (!opt.useFills) strcatX (temp, "(", 0); EncodeValuesFormat (Item->Var->dataType, Item->Var->numElems, Item->Var->fill, EofS(temp), NULL, 0, FILLitemLEN - 2, opt.epochStyle); if (!opt.useFills) strcatX (temp, ")", 0); CatToString (IWsel->iLines[lineN], temp, FILLitemLEN, LEFT_JUSTIFY, dots); } else CatNcharacters (IWsel->iLines[lineN], FILLitemLEN, ' '); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = FILLitemCOLn; IWsel->iLens[itemN] = FILLitemLEN; /********************************************************************* * Load monotonicity. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, MONOitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: CatToString (IWsel->iLines[lineN], monos[Item->Var->monotonic+1], MONOitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = MONOitemCOLn; IWsel->iLens[itemN] = MONOitemLEN; /********************************************************************* * Load format. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, FORMATitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: if (Item->Var->format != NULL) if ((EPOCHdataType(Item->Var->dataType) && (opt.epochStyle == EPOCH0_STYLE || opt.epochStyle == EPOCH1_STYLE || opt.epochStyle == EPOCH2_STYLE || opt.epochStyle == EPOCH3_STYLE)) || STRINGdataType(Item->Var->dataType)) { size_t nBytes = 1 + strlen(Item->Var->format) + 1; char *temp = (char *) cdf_AllocateMemory (nBytes + 1, FatalError); strcpyX (temp, "(", 0); strcatX (temp, Item->Var->format, 0); strcatX (temp, ")", 0); CatToString (IWsel->iLines[lineN], temp, FORMATitemLEN, LEFT_JUSTIFY, dots); cdf_FreeMemory (temp, FatalError); } else CatToString (IWsel->iLines[lineN], Item->Var->format, FORMATitemLEN, LEFT_JUSTIFY, dots); else CatNcharacters (IWsel->iLines[lineN], FORMATitemLEN, ' '); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = FORMATitemCOLn; IWsel->iLens[itemN] = FORMATitemLEN; /********************************************************************* * Load width. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); sprintf (temp, "%d", Item->width); CatToString (IWsel->iLines[lineN], temp, WIDTHitemLEN, LEFT_JUSTIFY, dots); itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = WIDTHitemCOLn; IWsel->iLens[itemN] = WIDTHitemLEN; } IWsel->nItems = itemN + 1; break; /************************************************************************** * Part 4. Name, sparseness, compression, blocking factor. **************************************************************************/ case PART4: for (Item = itemHead, lineN = 0; Item != NULL; Item = Item->nextItem, lineN++) { /********************************************************************* * Load item/variable name. *********************************************************************/ switch (Item->type) { case RECORDt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case INDICESt: MakeNUL (IWsel->iLines[lineN]); CatToString (IWsel->iLines[lineN], "", NAMEitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: EncodeString ((long) strlen(Item->Var->name), Item->Var->name, IWsel->iLines[lineN], -NAMEitemLEN, NAMEitemLEN); break; } itemN = nSELWINDOWcols4 * lineN; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = NAMEitemCOLn; IWsel->iLens[itemN] = NAMEitemLEN; /********************************************************************* * Load sparseness. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, SPARSEitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: CatToString (IWsel->iLines[lineN], SparsenessToken(Item->Var->sRecordsType, Item->Var->sArraysType, Item->Var->sArraysParms), SPARSEitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = SPARSEitemCOLn; IWsel->iLens[itemN] = SPARSEitemLEN; /********************************************************************* * Load compression. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, COMPRESSitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: CatToString (IWsel->iLines[lineN], CompressionToken(Item->Var->cType,Item->Var->cParms), COMPRESSitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = COMPRESSitemCOLn; IWsel->iLens[itemN] = COMPRESSitemLEN; /********************************************************************* * Load reserve percentage. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, RESERVEitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: if (Item->Var->reserve == NA_RESERVE) CatToString (IWsel->iLines[lineN], na, RESERVEitemLEN, LEFT_JUSTIFY, dots); else { sprintf (temp, "%ld", Item->Var->reserve); CatToString (IWsel->iLines[lineN], temp, RESERVEitemLEN, LEFT_JUSTIFY, dots); } break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = RESERVEitemCOLn; IWsel->iLens[itemN] = RESERVEitemLEN; /********************************************************************* * Load blocking factor. *********************************************************************/ strcatX (IWsel->iLines[lineN], " ", 0); switch (Item->type) { case RECORDt: case INDICESt: CatToString (IWsel->iLines[lineN], na, BLOCKINGitemLEN, LEFT_JUSTIFY, dots); break; case VARIABLEt: sprintf (temp, "%ld", Item->Var->blocking); CatToString (IWsel->iLines[lineN], temp, BLOCKINGitemLEN, LEFT_JUSTIFY, dots); break; } itemN++; IWsel->iLineNs[itemN] = lineN; IWsel->iCols[itemN] = BLOCKINGitemCOLn; IWsel->iLens[itemN] = BLOCKINGitemLEN; } IWsel->nItems = itemN + 1; break; } /**************************************************************************** * Success, return. ****************************************************************************/ return TRUE; } /****************************************************************************** * SelectionWindow. * This is used when `simple' mode has been selected. ******************************************************************************/ void SelectionWindow (noMoreAccess) Logical *noMoreAccess; /* Assumed initialized to FALSE by caller. */ { static Logical first = TRUE; int rX, cX, rXt; struct ItemStruct *Item; static char label[] = " SelectionWindow "; static char *header[] = { "Variable Output" }; static int exits[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, SCREENkey_SIMPLE, FILEkey_SIMPLE, SAVEkey_SIMPLE, RESTOREkey_SIMPLE, NUL }; static char keyDefs[] = "ToScreen: ________ SaveSettings: ________ Help: ________ YES/no: ________\n ToFile: ________ RestoreSettings: ________ Exit: ________"; /**************************************************************************** * Encode key definitions first time. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, SCREENkey_SIMPLE, SAVEkey_SIMPLE, HELPkey_FSI, ENTERkey_FSI, FILEkey_SIMPLE, RESTOREkey_SIMPLE, EXITkey_FSI); first = FALSE; } /**************************************************************************** * Load/update SelectionWindow. ****************************************************************************/ IWsel->label = label; IWsel->hLines = header; IWsel->exitChars = exits; LoadSelectionWindow (PART_); ItemWindow (UPDATEiw, IWsel, 1); /**************************************************************************** * Update/load KeyWindow. ****************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) /**************************************************************************** * Process keystrokes. ****************************************************************************/ for (;;) { ItemWindow (READiw, IWsel); rX = IWsel->itemN / nSELWINDOWcols_; cX = IWsel->itemN % nSELWINDOWcols_; for (Item = itemHead, rXt = 0; rXt < rX; rXt++) Item = Item->nextItem; switch (IWsel->key) { case ENTERkey_FSI: switch (cX) { case NAMEcxSIMPLE: ItemWindow (BEEPiw, IWsel); break; case OUTPUTcxSIMPLE: Item->outputSetting = BOO(Item->outputSetting,FALSE,TRUE); LoadSelectionWindow (PART_); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); break; } break; case SCREENkey_SIMPLE: if (!BOO(opt.horizontalMode,ToScreenHori(),ToScreenVert())) { *noMoreAccess = TRUE; return; } break; case FILEkey_SIMPLE: if (!BOO(opt.horizontalMode,ToFileHori(),ToFileVert())) { *noMoreAccess = TRUE; return; } break; case SAVEkey_SIMPLE: if (PromptFor(settingsFile,DU_MAX_PATH_LEN,strlen(settingsFile), "Enter path for settings file...",SETFILEhelpID)) { DisplayMessage ("Saving settings...", NOWAIT); SaveSettings (); DisplayMessage ("", NOWAIT); } break; case RESTOREkey_SIMPLE: if (PromptFor(settingsFile,DU_MAX_PATH_LEN,strlen(settingsFile), "Enter path for settings file...",SETFILEhelpID)) { DisplayMessage ("Restoring settings...", NOWAIT); RestoreSettings (); LoadSelectionWindow (PART_); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); DisplayMessage ("", NOWAIT); } break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", VARhelpID); break; case EXITkey_FSI: if (ConfirmExit()) return; break; } /************************************************************************* * Update key definitions in case they were changed. *************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) } } /****************************************************************************** * SelectionWindow1. * Returns FALSE when the CDF is to be exited (either by choice or because of * a fatal CDF error). ******************************************************************************/ Logical SelectionWindow1 (noMoreAccess) Logical *noMoreAccess; /* Assumed initialized to FALSE by caller. */ { static Logical first = TRUE; int rX, cX, rXt, itemN; struct ItemStruct *Item; static char label[] = " SelectionWindow, part 1 "; static char *header[] = { "Item/Variable DataSpec Dimensionality Variances Output" }; static int exits[] = { PART2key_EXPORT, ENTERkey_FSI, EXITkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, DELETEkey_FSI, HELPkey_FSI, OPTIONSkey_EXPORT, NUL }; static char keyDefs[] = "Modify: ________ Actions: ________ Reverse: ________ Help: ________\nPart 2: ________ Options: ________ Delete: ________ Exit: ________\n"; /**************************************************************************** * Encode key definitions first time. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, HELPkey_FSI, PART2key_EXPORT, OPTIONSkey_EXPORT, DELETEkey_FSI, EXITkey_FSI); first = FALSE; } /**************************************************************************** * Load/update SelectionWindow. ****************************************************************************/ IWsel->label = label; IWsel->hLines = header; IWsel->exitChars = exits; LoadSelectionWindow (PART1); itemN = (IWsel->itemN / nSELWINDOWcols4) * nSELWINDOWcols1; switch (IWsel->itemN % nSELWINDOWcols4) { case NAMEcx: break; case SPARSEcx: itemN += SPECcx; break; case COMPRESScx: itemN += VARYScx; break; case BLOCKINGcx: itemN += OUTPUTcx; break; } ItemWindow (UPDATEiw, IWsel, itemN); /**************************************************************************** * Update/load KeyWindow. ****************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) /**************************************************************************** * Process keystrokes. ****************************************************************************/ for (;;) { ItemWindow (READiw, IWsel); rX = IWsel->itemN / nSELWINDOWcols1; cX = IWsel->itemN % nSELWINDOWcols1; for (Item = itemHead, rXt = 0; rXt < rX; rXt++) Item = Item->nextItem; switch (IWsel->key) { case ENTERkey_FSI: switch (cX) { case NAMEcx: case SPECcx: case DIMENcx: case VARYScx: ItemWindow (BEEPiw, IWsel); break; case OUTPUTcx: Item->outputSetting = BOO(Item->outputSetting,FALSE,TRUE); LoadSelectionWindow (PART1); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); break; } break; case DELETEkey_FSI: switch (cX) { case NAMEcx: ItemWindow (BEEPiw, IWsel); break; case SPECcx: case DIMENcx: case VARYScx: case OUTPUTcx: ItemWindow (BEEPiw, IWsel); break; } break; case FLIPkey_EXPORT: if (FlipItems(rX)) { int itemN = (IWsel->itemN + nSELWINDOWcols1) % IWsel->nItems; LoadSelectionWindow (PART1); ItemWindow (UPDATEiw, IWsel, itemN); } else ItemWindow (BEEPiw, IWsel); break; case ACTIONSkey_EXPORT: if (!ActionMenu(PART1)) { *noMoreAccess = TRUE; return FALSE; } break; case OPTIONSkey_EXPORT: OptionMenu (); LoadSelectionWindow (PART1); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", VAR1helpID); break; case PART2key_EXPORT: return TRUE; case EXITkey_FSI: if (ConfirmExit()) return FALSE; break; } /************************************************************************* * Update key definitions in case they were changed. *************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) } } /****************************************************************************** * SelectionWindow2. * Returns FALSE when the CDF is to be exited (either by choice or because of * a fatal CDF error). ******************************************************************************/ Logical SelectionWindow2 (noMoreAccess) Logical *noMoreAccess; { static Logical first = TRUE; int rX, cX, rXt, itemN; struct ItemStruct *Item; static char label[] = " SelectionWindow, part 2 "; static char *header[] = { "Item/Variable Minimum Maximum Filter" }; static int exits[] = { PART3key_EXPORT, ENTERkey_FSI, EXITkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, DELETEkey_FSI, HELPkey_FSI, OPTIONSkey_EXPORT, NUL }; static char keyDefs[] = "Modify: ________ Actions: ________ Reverse: ________ Help: ________\nPart 3: ________ Options: ________ Delete: ________ Exit: ________\n"; /**************************************************************************** * Encode key definitions first time. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, HELPkey_FSI, PART2key_EXPORT, OPTIONSkey_EXPORT, DELETEkey_FSI, EXITkey_FSI); first = FALSE; } /**************************************************************************** * Load/update SelectionWindow. ****************************************************************************/ IWsel->label = label; IWsel->hLines = header; IWsel->exitChars = exits; LoadSelectionWindow (PART2); itemN = (IWsel->itemN / nSELWINDOWcols1) * nSELWINDOWcols2; switch (IWsel->itemN % nSELWINDOWcols1) { case NAMEcx: break; case SPECcx: itemN += MINcx; break; case DIMENcx: itemN += MINcx; break; case VARYScx: itemN += MAXcx; break; case OUTPUTcx: itemN += FILTERcx; break; } ItemWindow (UPDATEiw, IWsel, itemN); /**************************************************************************** * Load/update KeyWindow. ****************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) /**************************************************************************** * Process keystrokes. ****************************************************************************/ for (;;) { ItemWindow (READiw, IWsel); rX = IWsel->itemN / nSELWINDOWcols2; cX = IWsel->itemN % nSELWINDOWcols2; for (Item = itemHead, rXt = 0; rXt < rX; rXt++) Item = Item->nextItem; switch (IWsel->key) { case ENTERkey_FSI: switch (cX) { case NAMEcx: ItemWindow (BEEPiw, IWsel); break; case MINcx: case MAXcx: { switch (Item->type) { case RECORDt: case INDICESt: case VARIABLEt: if (PromptForMinMax(Item,(cX == MINcx))) { LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } break; case FILTERcx: if (MINorMAXexists(Item)) { if (opt.exclusive) { if (Item->filterSetting) { if (Item->inclusive) Item->inclusive = FALSE; else Item->filterSetting = FALSE; } else { Item->filterSetting = TRUE; Item->inclusive = TRUE; } } else Item->filterSetting = BOO(Item->filterSetting,FALSE,TRUE); opt.overallFilter = TRUE; LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; } } break; case DELETEkey_FSI: switch (cX) { case NAMEcx: ItemWindow (BEEPiw, IWsel); break; case MINcx: switch (Item->type) { case RECORDt: if (Item->Record->min != NOminMax) { Item->Record->min = NOminMax; if (Item->Record->max == NOminMax) { Item->filterSetting = FALSE; } LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; case INDICESt: if (Item->Indices->minNumDims != NOminMax) { Item->Indices->minNumDims = NOminMax; if (Item->Indices->maxNumDims == NOminMax) { Item->filterSetting = FALSE; } LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (Item->Var->min != NULL) { cdf_FreeMemory (Item->Var->min, FatalError); Item->Var->min = NULL; if (Item->Var->max == NULL) Item->filterSetting = FALSE; LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; } break; case MAXcx: switch (Item->type) { case RECORDt: if (Item->Record->max != NOminMax) { Item->Record->max = NOminMax; if (Item->Record->min == NOminMax) { Item->filterSetting = FALSE; } LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; case INDICESt: if (Item->Indices->maxNumDims != NOminMax) { Item->Indices->maxNumDims = NOminMax; if (Item->Indices->minNumDims == NOminMax) { Item->filterSetting = FALSE; } LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (Item->Var->max != NULL) { cdf_FreeMemory (Item->Var->max, FatalError); Item->Var->max = NULL; if (Item->Var->min == NULL) Item->filterSetting = FALSE; LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; } break; case FILTERcx: ItemWindow (BEEPiw, IWsel); break; } break; case FLIPkey_EXPORT: if (FlipItems(rX)) { int itemN = (IWsel->itemN + nSELWINDOWcols2) % IWsel->nItems; LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, itemN); } else ItemWindow (BEEPiw, IWsel); break; case ACTIONSkey_EXPORT: if (!ActionMenu(PART2)) { *noMoreAccess = TRUE; return FALSE; } break; case OPTIONSkey_EXPORT: OptionMenu (); LoadSelectionWindow (PART2); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", VAR2helpID); break; case PART3key_EXPORT: return TRUE; case EXITkey_FSI: if (ConfirmExit()) return FALSE; break; } /************************************************************************* * Update key definitions in case they were changed. *************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) } } /****************************************************************************** * SelectionWindow3. * Returns FALSE when the CDF is to be exited (either by choice or because of * a fatal CDF error). ******************************************************************************/ Logical SelectionWindow3 (noMoreAccess) Logical *noMoreAccess; { static Logical first = TRUE; int rX, cX, rXt, itemN; struct ItemStruct *Item; static char label[] = " SelectionWindow, part 3 "; static char *header[] = { "Item/Variable FillValue Monotonicity Format Width" }; static int exits[] = { PART4key_EXPORT, ENTERkey_FSI, EXITkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, DELETEkey_FSI, HELPkey_FSI, OPTIONSkey_EXPORT, NUL }; static char keyDefs[] = "Modify: ________ Actions: ________ Reverse: ________ Help: ________\nPart 4: ________ Options: ________ Delete: ________ Exit: ________\n"; /**************************************************************************** * Encode key definitions first time. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, HELPkey_FSI, PART4key_EXPORT, OPTIONSkey_EXPORT, DELETEkey_FSI, EXITkey_FSI); first = FALSE; } /**************************************************************************** * Load/update SelectionWindow. ****************************************************************************/ IWsel->label = label; IWsel->hLines = header; IWsel->exitChars = exits; LoadSelectionWindow (PART3); itemN = (IWsel->itemN / nSELWINDOWcols2) * nSELWINDOWcols3; switch (IWsel->itemN % nSELWINDOWcols2) { case NAMEcx: break; case MINcx: itemN += FILLcx; break; case MAXcx: itemN += MONOcx; break; case FILTERcx: itemN += WIDTHcx; break; } ItemWindow (UPDATEiw, IWsel, itemN); /**************************************************************************** * Load/update KeyWindow. ****************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) /**************************************************************************** * Process keystrokes. ****************************************************************************/ for (;;) { ItemWindow (READiw, IWsel); rX = IWsel->itemN / nSELWINDOWcols3; cX = IWsel->itemN % nSELWINDOWcols3; for (Item = itemHead, rXt = 0; rXt < rX; rXt++) Item = Item->nextItem; switch (IWsel->key) { case ENTERkey_FSI: switch (cX) { case NAMEcx: ItemWindow (BEEPiw, IWsel); break; case FILLcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (PromptForFill(Item->Var)) { LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } break; case WIDTHcx: { if (PromptForWidth(Item)) { LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } case MONOcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (Item->Var->monotonic != NAmono) { Item->Var->monotonic = (Item->Var->monotonic + 1) % 4; LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; } break; case FORMATcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (PromptForFormat(Item)) { LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } break; } break; case DELETEkey_FSI: switch (cX) { case NAMEcx: ItemWindow (BEEPiw, IWsel); break; case FILLcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (Item->Var->fill != NULL) { cdf_FreeMemory (Item->Var->fill, FatalError); Item->Var->fill = NULL; LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; } break; case WIDTHcx: case MONOcx: ItemWindow (BEEPiw, IWsel); break; case FORMATcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (Item->Var->format != NULL) { cdf_FreeMemory (Item->Var->format, FatalError); Item->Var->format = NULL; LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } else ItemWindow (BEEPiw, IWsel); break; } break; } break; case FLIPkey_EXPORT: if (FlipItems(rX)) { int itemN = (IWsel->itemN + nSELWINDOWcols3) % IWsel->nItems; LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, itemN); } else ItemWindow (BEEPiw, IWsel); break; case ACTIONSkey_EXPORT: if (!ActionMenu(PART3)) { *noMoreAccess = TRUE; return FALSE; } break; case OPTIONSkey_EXPORT: OptionMenu (); LoadSelectionWindow (PART3); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", VAR3helpID); break; case PART4key_EXPORT: return TRUE; case EXITkey_FSI: if (ConfirmExit()) return FALSE; break; } /************************************************************************* * Update key definitions in case they were changed. *************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) } } /****************************************************************************** * SelectionWindow4. * Returns FALSE when the CDF is to be exited (either by choice or because of * a fatal CDF error). ******************************************************************************/ Logical SelectionWindow4 (noMoreAccess) Logical *noMoreAccess; { static Logical first = TRUE; int rX, cX, rXt, itemN; struct ItemStruct *Item; static char label[] = " SelectionWindow, part 4 "; static char *header[] = { "Item/Variable Sparseness Compression Reserve Blocking" }; static int exits[] = { PART1key_EXPORT, ENTERkey_FSI, EXITkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, DELETEkey_FSI, HELPkey_FSI, OPTIONSkey_EXPORT, NUL }; static char keyDefs[] = "Modify: ________ Actions: ________ Reverse: ________ Help: ________\nPart 1: ________ Options: ________ Delete: ________ Exit: ________\n"; /**************************************************************************** * Encode key definitions first time. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, ACTIONSkey_EXPORT, FLIPkey_EXPORT, HELPkey_FSI, PART1key_EXPORT, OPTIONSkey_EXPORT, DELETEkey_FSI, EXITkey_FSI); first = FALSE; } /**************************************************************************** * Load/update SelectionWindow. ****************************************************************************/ IWsel->label = label; IWsel->hLines = header; IWsel->exitChars = exits; LoadSelectionWindow (PART4); itemN = (IWsel->itemN / nSELWINDOWcols3) * nSELWINDOWcols4; switch (IWsel->itemN % nSELWINDOWcols3) { case NAMEcx: break; case FILLcx: itemN += SPARSEcx; break; case MONOcx: itemN += COMPRESScx; break; case FORMATcx: itemN += RESERVEcx; break; case WIDTHcx: itemN += BLOCKINGcx; break; } ItemWindow (UPDATEiw, IWsel, itemN); /**************************************************************************** * Load/update KeyWindow. ****************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) /**************************************************************************** * Process keystrokes. ****************************************************************************/ for (;;) { ItemWindow (READiw, IWsel); rX = IWsel->itemN / nSELWINDOWcols4; cX = IWsel->itemN % nSELWINDOWcols4; for (Item = itemHead, rXt = 0; rXt < rX; rXt++) Item = Item->nextItem; switch (IWsel->key) { case ENTERkey_FSI: switch (cX) { case NAMEcx: ItemWindow (BEEPiw, IWsel); break; case SPARSEcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (PromptForSparseness(Item->Var)) { LoadSelectionWindow (PART4); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } break; case COMPRESScx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: { long cType, cParms[CDF_MAX_PARMS]; int parmN; if (PromptForCompression(&cType,cParms)) { Item->Var->cType = cType; for (parmN = 0; parmN < CDF_MAX_PARMS; parmN++) { Item->Var->cParms[parmN] = cParms[parmN]; } Item->Var->reserve = BOO(Item->Var->cType == NO_COMPRESSION, NA_RESERVE,0); LoadSelectionWindow (PART4); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } } break; case RESERVEcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (Item->Var->reserve != NA_RESERVE) { if (PromptForReserve(Item->Var)) { LoadSelectionWindow (PART4); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } } else ItemWindow (BEEPiw, IWsel); break; } break; case BLOCKINGcx: switch (Item->type) { case RECORDt: case INDICESt: ItemWindow (BEEPiw, IWsel); break; case VARIABLEt: if (PromptForBlocking(Item->Var)) { LoadSelectionWindow (PART4); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } break; } break; } break; case DELETEkey_FSI: switch (cX) { case NAMEcx: case SPARSEcx: case COMPRESScx: case RESERVEcx: case BLOCKINGcx: ItemWindow (BEEPiw, IWsel); break; } break; case FLIPkey_EXPORT: if (FlipItems(rX)) { int itemN = (IWsel->itemN + nSELWINDOWcols4) % IWsel->nItems; LoadSelectionWindow (PART4); ItemWindow (UPDATEiw, IWsel, itemN); } else ItemWindow (BEEPiw, IWsel); break; case ACTIONSkey_EXPORT: if (!ActionMenu(PART4)) { *noMoreAccess = TRUE; return FALSE; } break; case OPTIONSkey_EXPORT: OptionMenu (); LoadSelectionWindow (PART4); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", VAR4helpID); break; case PART1key_EXPORT: return TRUE; case EXITkey_FSI: if (ConfirmExit()) return FALSE; break; } /************************************************************************* * Update key definitions in case they were changed. *************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) } } /****************************************************************************** * ActionMenu. * Returns FALSE if no more access to the CDF. ******************************************************************************/ Logical ActionMenu (part) int part; { static Logical first = TRUE; static int actExits[] = { ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI, NUL }; static char *actLines1[] = { "List to screen", "List to file...", "Output to CDF(V2.7)...", "Walk on screen", "Output all items/variables", "Output no items/variables", "Filter all items/variables", "Filter no items/variables", "Set CDF's compression...", "Set variable compressions...", "Save settings...", "Restore settings...", "Set monotonicities", "Set CDF's checksum..." }; static char *actLines2[] = { "List to screen", "List to file...", "Output to CDF(V3)...", "Output to CDF(V2.7)...", "Walk on screen", "Output all items/variables", "Output no items/variables", "Filter all items/variables", "Filter no items/variables", "Set CDF's compression", "Set variable compressions...", "Save settings...", "Restore settings...", "Set monotonicities", "Set CDF's checksum..." }; static int actLineNs1[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13 }; static int actCols1[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; static int actLens1[] = { 33,33,33,33,33,33,33,33,33,33,33,33,33,33 }; static int actLineNs2[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14 }; static int actCols2[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; static int actLens2[] = { 33,33,33,33,33,33,33,33,33,33,33,33,33,33,33 }; static struct ItemWindowStruct IWact1 = { 1, 44, 35, " ActionMenu ", 0, NULL, 14, actLines1, 14, actLineNs1, actCols1, actLens1, 14, 0, NULL, actExits, REFRESHkey_FSI, FALSE, NUL, NUL }; static struct ItemWindowStruct IWact2 = { 1, 44, 35, " ActionMenu ", 0, NULL, 15, actLines2, 15, actLineNs2, actCols2, actLens2, 15, 0, NULL, actExits, REFRESHkey_FSI, FALSE, NUL, NUL }; static struct ItemWindowStruct IWact; struct ItemStruct *Item; static char keyDefs[] = { "Select: ________ Help: ________ Exit: ________\n\n" }; int ix = 0, iy; /**************************************************************************** * Create ActionMenu and process keystrokes. ****************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); first = FALSE; } if (CDFgetFileBackwardEnvVar() == 1) IWact = IWact1; else { IWact = IWact2; ix = 1; } ItemWindow (NEWiw, &IWact, 0); for (;;) { NEWkeyDEFS (EWkey, keyDefs, batchMode) ItemWindow (READiw, &IWact); switch (IWact.key) { case ENTERkey_FSI: { iy = IWact.itemN; if (ix == 0) { if (iy == TOCDFact) iy = TOCDFv2act; /* TOCDFv2act */ } else { if (iy == (TOCDFact + 1)) iy = TOCDFv2act; else if ((iy > (TOCDFact + 1)) && (iy != SETcdfCHECKSUMact)) iy--; } switch (iy) { case TOSCREENact: ItemWindow (DELETEiw, &IWact); return BOO(opt.horizontalMode,ToScreenHori(),ToScreenVert()); case TOFILEact: ItemWindow (DELETEiw, &IWact); return BOO(opt.horizontalMode,ToFileHori(),ToFileVert()); case TOCDFact: case TOCDFv2act: { CDFstatus status; CDFid inID; ItemWindow (DELETEiw, &IWact); status = CDFlib (CONFIRM_, CDF_, &inID, NULL_); DisplayStatus (status, "confirming input CDF"); if (StatusBAD(status)) return FALSE; CDFsetFileBackward(BACKWARDFILEoff); if (iy == TOCDFv2act) CDFsetFileBackward(BACKWARDFILEon); return ToCDF(inID); } case WALKact: { ItemWindow (DELETEiw, &IWact); return ToWalk(); } case OUTPUTallITEMSact: case OUTPUTnoITEMSact: { Logical state = (IWact.itemN == OUTPUTallITEMSact); ItemWindow (DELETEiw, &IWact); DisplayMessage (BOO(state,"Setting `outputs' to `YES'.", "Setting `outputs' to `no'"), NOWAIT); for (Item = itemHead; Item != NULL; Item = Item->nextItem) { Item->outputSetting = state; } LoadSelectionWindow (part); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); DisplayMessage ("", NOWAIT); return TRUE; } case FILTERallITEMSact: ItemWindow (DELETEiw, &IWact); DisplayMessage ("Setting `filters' to `YES'.", NOWAIT); for (Item = itemHead; Item != NULL; Item = Item->nextItem) { switch (Item->type) { case RECORDt: if (Item->Record->min != NOminMax || Item->Record->max != NOminMax) { Item->filterSetting = TRUE; } break; case INDICESt: if (Item->Indices->minNumDims != NOminMax || Item->Indices->maxNumDims != NOminMax) { Item->filterSetting = TRUE; } break; case VARIABLEt: if (Item->Var->min != NULL || Item->Var->max != NULL) Item->filterSetting = TRUE; break; } } LoadSelectionWindow (part); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); DisplayMessage ("", NOWAIT); return TRUE; case FILTERnoITEMSact: ItemWindow (DELETEiw, &IWact); DisplayMessage ("Setting `filters' to `no'.", NOWAIT); for (Item = itemHead; Item != NULL; Item = Item->nextItem) { Item->filterSetting = FALSE; } LoadSelectionWindow (part); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); DisplayMessage ("", NOWAIT); return TRUE; case SETcdfCOMPRESSact: { long cType, cParms[CDF_MAX_PARMS]; int parmN; ItemWindow (DELETEiw, &IWact); if (PromptForCompression(&cType,cParms)) { CDFcType = cType; for (parmN = 0; parmN < CDF_MAX_PARMS; parmN++) { CDFcParms[parmN] = cParms[parmN]; } LoadCDFwindow (NULL); FieldWindow (UPDATEfw, FWcdf, 0, LogicalTRUE); } return TRUE; } case SETvarCOMPRESSact: { long cType, cParms[CDF_MAX_PARMS]; int parmN; ItemWindow (DELETEiw, &IWact); if (PromptForCompression(&cType,cParms)) { for (Item = itemHead; Item != NULL; Item = Item->nextItem) { switch (Item->type) { case RECORDt: case INDICESt: break; case VARIABLEt: Item->Var->cType = cType; for (parmN = 0; parmN < CDF_MAX_PARMS; parmN++) { Item->Var->cParms[parmN] = cParms[parmN]; } break; } } LoadSelectionWindow (part); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); } return TRUE; } case SAVEact: ItemWindow (DELETEiw, &IWact); if (PromptFor(settingsFile,DU_MAX_PATH_LEN,strlen(settingsFile), "Enter path for settings file...",SETFILEhelpID)) { DisplayMessage ("Saving settings...", NOWAIT); SaveSettings (); DisplayMessage ("", NOWAIT); } return TRUE; case RESTOREact: ItemWindow (DELETEiw, &IWact); if (PromptFor(settingsFile,DU_MAX_PATH_LEN,strlen(settingsFile), "Enter path for settings file...",SETFILEhelpID)) { DisplayMessage ("Restoring settings...", NOWAIT); RestoreSettings (); LoadSelectionWindow (part); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); DisplayMessage ("", NOWAIT); } return TRUE; case SETMONOact: ItemWindow (DELETEiw, &IWact); if (!SetItemMonotonicities()) return FALSE; LoadSelectionWindow (part); ItemWindow (UPDATEiw, IWsel, IWsel->itemN); return TRUE; case SETcdfCHECKSUMact: { long checksum; ItemWindow (DELETEiw, &IWact); if (PromptForChecksum(&checksum)) { CDFchecksum = checksum; LoadCDFwindow (NULL); FieldWindow (UPDATEfw, FWcdf, 0, LogicalTRUE); } return TRUE; } } break; } case HELPkey_FSI: if (CDFgetFileBackwardEnvVar() == 1) OnlineHelpWindow ("cdfxp.ilh", ACTIONhelpID); else OnlineHelpWindow ("cdfxp.ilh", ACTIONv32helpID); break; case EXITkey_FSI: ItemWindow (DELETEiw, &IWact); return TRUE; } } } /****************************************************************************** * OptionMenu. ******************************************************************************/ void OptionMenu () { Logical first = TRUE; struct OptionStruct optSave; static long nextEncoding[] = { 0L, SUN_ENCODING, VAX_ENCODING, DECSTATION_ENCODING, SGi_ENCODING, IBMPC_ENCODING, IBMRS_ENCODING, HOST_ENCODING, MAC_ENCODING, HP_ENCODING, 0L, NeXT_ENCODING, ALPHAOSF1_ENCODING, ALPHAVMSd_ENCODING, ALPHAVMSg_ENCODING, ALPHAVMSi_ENCODING, NETWORK_ENCODING }; static long prevEncoding[] = { 0L, ALPHAVMSi_ENCODING, NETWORK_ENCODING, SUN_ENCODING, VAX_ENCODING, DECSTATION_ENCODING, SGi_ENCODING, IBMPC_ENCODING, IBMRS_ENCODING, HOST_ENCODING, 0L, MAC_ENCODING, HP_ENCODING, NeXT_ENCODING, ALPHAOSF1_ENCODING, ALPHAVMSd_ENCODING, ALPHAVMSg_ENCODING }; static int optExits[] = { ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI, NEXTFIELDkey_EXPORT, PREVFIELDkey_EXPORT, NUL }; AOSs15 (optLines, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40, BLANKs40) static int optLineNs[] = { 0,1,2,3,4,5,6,7,8,9,10,11 }; static int optCols[] = { 0,0,0,0,0,0,0,0,0,0,0,0 }; static int optLens[] = { 33,33,33,33,33,33,33,33,33,33,33,33 }; static struct ItemWindowStruct IWopt = { 1, 44, 35, " OptionMenu ", 0, NULL, 12, optLines, 12, optLineNs, optCols, optLens, 13, 0, NULL, optExits, REFRESHkey_FSI, FALSE, NUL, NUL }; static char keyDefs[] = "Enter: ________ Increment: ____________ Help: ________\nExit: ________ Decrement: ____________\n"; /**************************************************************************** * Display OptionMenu and process keystrokes until exit requested. ****************************************************************************/ for (;;) { /************************************************************************* * Initialize/update OptionMenu lines. *************************************************************************/ sprintf (IWopt.iLines[FILTERrx], "Use filters: %s", BOO(opt.overallFilter,"YES","no")); sprintf (IWopt.iLines[FILLSrx], "Use fill values: %s", BOO(opt.useFills,"YES","no")); sprintf (IWopt.iLines[CDFFORMATrx], "Create %s-file CDFs", BOO(opt.singleFile,"single","multi")); sprintf (IWopt.iLines[ENCODINGrx], "Create %s-encoded CDFs", encodings[(int)opt.encoding]); sprintf (IWopt.iLines[EPOCHrx], "EPOCH style: %s", epochStyles[opt.epochStyle]); sprintf (IWopt.iLines[hvMODErx], "%s listings", BOO(opt.horizontalMode,"Horizontal","Vertical")); sprintf (IWopt.iLines[MAJORrx], "Majority: %s", majorities[(int)opt.majority]); sprintf (IWopt.iLines[SHOWrx], "Show filtered lines: %s", BOO(opt.showFiltered,"YES","no")); sprintf (IWopt.iLines[SPACINGrx], "Item/variable spacing: %d", opt.spacing); sprintf (IWopt.iLines[DELETErx], "Delete existing CDF: %s", BOO(opt.deleteExisting,"YES, beware!","no")); sprintf (IWopt.iLines[PREALLOCrx], "Preallocate records: %s", BOO(opt.preAllocate,"YES","no")); sprintf (IWopt.iLines[HEADINGrx], "Display heading: %s", BOO(opt.textHeading,"YES","no")); /************************************************************************* * Create OptionMenu and encode key definitions first time. Just update * the OptionMenu all the following times. *************************************************************************/ if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, NEXTFIELDkey_EXPORT, HELPkey_FSI, EXITkey_FSI, PREVFIELDkey_EXPORT); ItemWindow (NEWiw, &IWopt, 0); memmove (&optSave, &opt, sizeof(struct OptionStruct)); first = FALSE; } else ItemWindow (UPDATEiw, &IWopt, IWopt.itemN); /************************************************************************* * Update key definitions (in case there were changed). *************************************************************************/ NEWkeyDEFS (EWkey, keyDefs, batchMode) /************************************************************************* * Process keystroke. *************************************************************************/ ItemWindow (READiw, &IWopt); switch (IWopt.key) { case ENTERkey_FSI: ItemWindow (DELETEiw, &IWopt); return; case NEXTFIELDkey_EXPORT: switch (IWopt.itemN) { case FILTERrx: opt.overallFilter = BOO(opt.overallFilter,FALSE,TRUE); break; case FILLSrx: opt.useFills = BOO(opt.useFills,FALSE,TRUE); break; case CDFFORMATrx: opt.singleFile = BOO(opt.singleFile,FALSE,TRUE); break; case hvMODErx: opt.horizontalMode = BOO(opt.horizontalMode,FALSE,TRUE); break; case SHOWrx: opt.showFiltered = BOO(opt.showFiltered,FALSE,TRUE); break; case DELETErx: opt.deleteExisting = BOO(opt.deleteExisting,FALSE,TRUE); break; case PREALLOCrx: opt.preAllocate = BOO(opt.preAllocate,FALSE,TRUE); break; case HEADINGrx: opt.textHeading = BOO(opt.textHeading,FALSE,TRUE); break; case MAJORrx: opt.majority = BOO(opt.majority == COLUMN_MAJOR, INPUT_MAJOR,opt.majority + 1); break; case ENCODINGrx: opt.encoding = nextEncoding[(int)opt.encoding]; break; case EPOCHrx: opt.epochStyle = BOO(opt.epochStyle == EPOCHx_STYLE, EPOCH0_STYLE,opt.epochStyle + 1); break; case SPACINGrx: opt.spacing++; break; } break; case PREVFIELDkey_EXPORT: switch (IWopt.itemN) { case FILTERrx: opt.overallFilter = BOO(opt.overallFilter,FALSE,TRUE); break; case FILLSrx: opt.useFills = BOO(opt.useFills,FALSE,TRUE); break; case CDFFORMATrx: opt.singleFile = BOO(opt.singleFile,FALSE,TRUE); break; case hvMODErx: opt.horizontalMode = BOO(opt.horizontalMode,FALSE,TRUE); break; case SHOWrx: opt.showFiltered = BOO(opt.showFiltered,FALSE,TRUE); break; case DELETErx: opt.deleteExisting = BOO(opt.deleteExisting,FALSE,TRUE); break; case PREALLOCrx: opt.preAllocate = BOO(opt.preAllocate,FALSE,TRUE); break; case HEADINGrx: opt.textHeading = BOO(opt.textHeading,FALSE,TRUE); break; case MAJORrx: opt.majority = BOO(opt.majority == INPUT_MAJOR, COLUMN_MAJOR,opt.majority - 1); break; case ENCODINGrx: opt.encoding = prevEncoding[(int)opt.encoding]; break; case EPOCHrx: opt.epochStyle = BOO(opt.epochStyle == EPOCH0_STYLE, EPOCHx_STYLE,opt.epochStyle - 1); break; case SPACINGrx: if (opt.spacing > 0) opt.spacing--; else ItemWindow (BEEPiw, &IWopt); break; } break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", OPTIONhelpID); break; case EXITkey_FSI: ItemWindow (DELETEiw, &IWopt); memmove (&opt, &optSave, sizeof(struct OptionStruct)); return; } } } /****************************************************************************** * ConfirmExit. * Returns TRUE if exit should proceed. FALSE if exit should be aborted. ******************************************************************************/ Logical ConfirmExit () { return TRUE; } /****************************************************************************** * DisplayStatus. ******************************************************************************/ void DisplayStatus (status, text) CDFstatus status; char *text; { if (status == CDF_OK) return; if (StatusINFO(status)) { if (report[INFOs]) { char explanation[CDF_STATUSTEXT_LEN+1], msg[MAX_MESSAGE_TEXT_LEN+1]; CDFlib (SELECT_, CDF_STATUS_, status, GET_, STATUS_TEXT_, explanation, NULL_); strcpyX (msg, "Informational...while ", MAX_MESSAGE_TEXT_LEN); strcatX (msg, text, MAX_MESSAGE_TEXT_LEN); strcatX (msg, ".", MAX_MESSAGE_TEXT_LEN); DisplayMessage (msg, NOBEEPWAIT1); DisplayMessage (explanation, NOBEEPWAIT1); } return; } if (StatusWARN(status)) { if (report[WARNs]) { char explanation[CDF_STATUSTEXT_LEN+1], msg[MAX_MESSAGE_TEXT_LEN+1]; CDFlib (SELECT_, CDF_STATUS_, status, GET_, STATUS_TEXT_, explanation, NULL_); strcpyX (msg, "Warning...while ", MAX_MESSAGE_TEXT_LEN); strcatX (msg, text, MAX_MESSAGE_TEXT_LEN); strcatX (msg, ".", MAX_MESSAGE_TEXT_LEN); DisplayMessage (msg, BEEPWAIT1); DisplayMessage (explanation, BEEPWAIT1); } return; } if (report[ERRORs]) { char explanation[CDF_STATUSTEXT_LEN+1], msg[MAX_MESSAGE_TEXT_LEN+1]; CDFlib (SELECT_, CDF_STATUS_, status, GET_, STATUS_TEXT_, explanation, NULL_); strcpyX (msg, "ERROR...while ", MAX_MESSAGE_TEXT_LEN); strcatX (msg, text, MAX_MESSAGE_TEXT_LEN); strcatX (msg, ".", MAX_MESSAGE_TEXT_LEN); DisplayMessage (msg, BEEPWAIT1); DisplayMessage (explanation, BEEPWAIT); } return; } /****************************************************************************** * DisplayMessage. * wait = NOWAIT. Return immediately, do not clear message. NUL is * returned. * wait = NOBEEPWAIT. Wait for user input then clear message. The key * entered is returned. * wait = NOBEEPWAIT1. Wait one second then clear message. NUL is returned. * wait = NOBEEPWAIT2. Wait two seconds then clear message. NUL is returned. * wait = BEEPWAIT. Beep, wait for user input then clear message. The key * entered is returned. * wait = BEEPWAIT1. Beep, wait one second then clear message. NUL is * returned. * wait = BEEPWAIT2. Beep, wait two seconds then clear message. NUL is * returned. ******************************************************************************/ int DisplayMessage (message, wait) char *message; int wait; { /**************************************************************************** * If batch mode, just print the message to the standard output. ****************************************************************************/ if (BATCH(batchMode)) { printf ("%s\n", message); return 0; } /**************************************************************************** * Otherwise... ****************************************************************************/ strcpyX (EWmsg->eText, message, EWmsg->nColsTotal - 2); switch (wait) { case NOWAIT: EditWindow (UPDATEew, EWmsg, LogicalTRUE); return 0; case NOBEEPWAIT: case BEEPWAIT: { static char newLabel[] = { " Enter any key to acknowledge. " }; char *saveLabel = EWmsg->label; EWmsg->label = newLabel; EditWindow (UPDATEew, EWmsg, LogicalTRUE); if (wait == BEEPWAIT) EditWindow (BEEPew, EWmsg); EditWindow (READew, EWmsg); MakeNUL (EWmsg->eText); EWmsg->label = saveLabel; EditWindow (UPDATEew, EWmsg, LogicalTRUE); return EWmsg->key; } case NOBEEPWAIT1: case NOBEEPWAIT2: case BEEPWAIT1: case BEEPWAIT2: { double seconds = BOO((wait == NOBEEPWAIT1 || wait == BEEPWAIT1),1.0,2.0); EditWindow (UPDATEew, EWmsg, LogicalTRUE); if (wait == BEEPWAIT1 || wait == BEEPWAIT2) EditWindow (BEEPew, EWmsg); zzzzz (seconds); MakeNUL (EWmsg->eText); EditWindow (UPDATEew, EWmsg, LogicalTRUE); return 0; } } return 0; } /****************************************************************************** * MatchOption. * Returns `AMBIGUOUSopt' if ambiguous, `UNKNOWNopt' if not found. ******************************************************************************/ int MatchOption (option, validOptions) char *option; char *validOptions[]; { int i, j; /**************************************************************************** * First try for an exact match. ****************************************************************************/ for (i = 0; validOptions[i] != NULL; i++) { if (strcmpIgCase(option,validOptions[i]) != 0) return i; } /**************************************************************************** * Check if the option matches the first part of one of the valid options * (ie. it has been abbreviated by truncation). If so, make sure that it * cannot be any of the other valid options (ie. ambiguous). ****************************************************************************/ for (i = 0; validOptions[i] != NULL; i++) { if (strncmpIgCasePattern(option,validOptions[i],strlen(option)) == 0) { for (j = i + 1; validOptions[j] != NULL; j++) { if (strncmpIgCasePattern(option,validOptions[j],strlen(option)) == 0) return AMBIGUOUSopt; } return i; } } /**************************************************************************** * The option was not found. ****************************************************************************/ return UNKNOWNopt; } /****************************************************************************** * FreeItems. ******************************************************************************/ void FreeItems () { struct ItemStruct *Item = itemHead, *tItem; while (Item != NULL) { tItem = Item->nextItem; switch (Item->type) { case RECORDt: cdf_FreeMemory (Item->Record, FatalError); break; case INDICESt: cdf_FreeMemory (Item->Indices, FatalError); break; case VARIABLEt: if (Item->Var->name != NULL) cdf_FreeMemory (Item->Var->name, FatalError); if (Item->Var->min != NULL) cdf_FreeMemory (Item->Var->min, FatalError); if (Item->Var->max != NULL) cdf_FreeMemory (Item->Var->max, FatalError); if (Item->Var->format != NULL) cdf_FreeMemory (Item->Var->format, FatalError); if (Item->Var->fill != NULL) cdf_FreeMemory (Item->Var->fill, FatalError); if (Item->Var->pad != NULL) cdf_FreeMemory (Item->Var->pad, FatalError); if (Item->Var->value != NULL) cdf_FreeMemory (Item->Var->value, FatalError); cdf_FreeMemory (Item->Var, FatalError); break; } cdf_FreeMemory (Item, FatalError); Item = tItem; } itemHead = NULL; return; } /****************************************************************************** * LongValueWidth. ******************************************************************************/ int LongValueWidth (value) long value; { int width = 1; long tmp = value / 10; while (tmp != 0) { width++; tmp = tmp / 10; } return width; } /****************************************************************************** * RecordIndicesWidth. ******************************************************************************/ int RecordIndicesWidth (lastRec, numDims, dimSizes, type) long lastRec; long numDims; long dimSizes[]; int type; { switch (type) { case RECORDt: return MaxInt(LongValueWidth(lastRec),MIN_RECORD_WIDTH); case INDICESt: { int n, indicesW = (int) (1 + BOO(numDims > 1,numDims - 1,0) + 1); for (n = 0; n < numDims; n++) indicesW += LongValueWidth(dimSizes[n]); return MAXIMUM(indicesW,MIN_INDICES_WIDTH); } } return 0; } /****************************************************************************** * FreeToScreen. ******************************************************************************/ void FreeToScreen (header, scrLines, trailer) char *header[]; char *scrLines[]; char *trailer[]; { int lineN; cdf_FreeMemory (header[0], FatalError); for (lineN = 0; lineN < NUMscreenLINES; lineN++) { cdf_FreeMemory (scrLines[lineN], FatalError); } cdf_FreeMemory (trailer[0], FatalError); return; } /****************************************************************************** * PromptFor. ******************************************************************************/ Logical PromptFor (value, valueL, cursorAt, label, helpID) char *value; int valueL; int cursorAt; char *label; int helpID; { static Logical first = TRUE; static int exits[] = { ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI, NUL }; static struct PromptWindowStruct PW = { NULL, 21, 0, SCREEN_WIDTH, 0, NULL, 0, NULL, 0, NULL, exits, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI }; static char keyDefsBlank[] = "\n\n"; static char keyDefsPrompt[] = { "Enter: ________ Help: ________ Exit: ________\n\n" }; if (first) { char *p1 = keyDefsPrompt; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); first = FALSE; } PW.label = label; PW.maxChars = valueL; PW.value = value; PromptWindow (NEWpw, &PW, cursorAt, LogicalTRUE); NEWkeyDEFS (EWkey, keyDefsPrompt, batchMode) for (;;) { PromptWindow (READpw, &PW); switch (PW.key) { case ENTERkey_FSI: PromptWindow (DELETEpw, &PW); NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) return TRUE; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", helpID); break; case EXITkey_FSI: PromptWindow (DELETEpw, &PW); NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) return FALSE; } } } /****************************************************************************** * PromptForMinMax. ******************************************************************************/ Logical PromptForMinMax (Item, min) struct ItemStruct *Item; Logical min; { static char value[MAXminMaxLEN+1]; static char minGTmaxMsg[] = { "That minimum would be greater than the current maximum." }; static char maxLTminMsg[] = { "That maximum would be less than the current minimum." }; switch (Item->type) { /************************************************************************** * Record. **************************************************************************/ case RECORDt: { long *mmPtr = BOO(min,&(Item->Record->min),&(Item->Record->max)); long *mmPtrX = BOO(min,&(Item->Record->max),&(Item->Record->min)); long newValue; /************************************************************************ * Set initial value. ************************************************************************/ if (*mmPtr == NOminMax) MakeNUL (value); else sprintf (value, "%ld", *mmPtr + 1); /************************************************************************ * Prompt for new value. ************************************************************************/ if (!PromptFor(value,MAXminMaxLEN,strlen(value), BOO(min,"Enter new minimum record...", "Enter new maximum record..."), MINmaxRECORDhelpID)) { return FALSE; } /************************************************************************ * Entering nothing erases the current value. ************************************************************************/ if (NULstring(value)) { if (*mmPtr != NOminMax) { *mmPtr = NOminMax; if (*mmPtrX == NOminMax) Item->filterSetting = FALSE; return TRUE; } else return FALSE; } /************************************************************************ * Decode the value entered. ************************************************************************/ if (sscanf(value,"%ld",&newValue) != 1) { DisplayMessage ("Error decoding value.", BEEPWAIT1); return FALSE; } else newValue--; /************************************************************************ * Validate the value entered. ************************************************************************/ if (newValue < 0) { DisplayMessage ("Illegal value.", BEEPWAIT1); return FALSE; } /************************************************************************ * Make sure the new minimum is not greater than the current maximum. ************************************************************************/ if (min && Item->Record->max != NOminMax) { if (newValue > Item->Record->max) { DisplayMessage (minGTmaxMsg, BEEPWAIT1); return FALSE; } } /************************************************************************ * Make sure the new maximum is not less than the current minimum. ************************************************************************/ if (!min && Item->Record->min != NOminMax) { if (newValue < Item->Record->min) { DisplayMessage (maxLTminMsg, BEEPWAIT1); return FALSE; } } /************************************************************************ * Everything's OK, save the new value entered. ************************************************************************/ *mmPtr = newValue; Item->filterSetting = TRUE; opt.overallFilter = TRUE; break; } /************************************************************************** * Indices. **************************************************************************/ case INDICESt: { long *mmNumDims = BOO(min,&(Item->Indices->minNumDims), &(Item->Indices->maxNumDims)), *mmNumDimsX = BOO(min,&(Item->Indices->maxNumDims), &(Item->Indices->minNumDims)), *mmIndices = BOO(min,Item->Indices->minIndices, Item->Indices->maxIndices), newNumDims, newIndices[CDF_MAX_DIMS]; int dimN; /************************************************************************ * Set initial indices. ************************************************************************/ if (*mmNumDims == NOminMax) strcpyX (value, "[]", MAXminMaxLEN); else EncodeIndicesJustify (value, *mmNumDims, mmIndices, 0); /************************************************************************ * Prompt for new indices. ************************************************************************/ if (!PromptFor(value,MAXminMaxLEN,strlen(value)-1, BOO(min,"Enter new minimum indices...", "Enter new maximum indices..."), MINmaxINDICEShelpID)) { return FALSE; } /************************************************************************ * Entering nothing erases the current indices. ************************************************************************/ if (NULstring(value)) { if (*mmNumDims != NOminMax) { *mmNumDims = NOminMax; if (*mmNumDimsX == NOminMax) Item->filterSetting = FALSE; return TRUE; } else return FALSE; } /************************************************************************ * Decode the indices entered. ************************************************************************/ if (!DecodeRecordAndIndices(value,NULL,&newNumDims,newIndices)) { DisplayMessage ("Error decoding indices.", BEEPWAIT1); return FALSE; } /************************************************************************ * Validate the indices entered. ************************************************************************/ if (newNumDims == 0) { DisplayMessage ("Zero dimensions not allowed.", BEEPWAIT1); return FALSE; } for (dimN = 0; dimN < newNumDims; dimN++) { if (newIndices[dimN] < 0) { DisplayMessage ("Illegal indices.", BEEPWAIT1); return FALSE; } } /************************************************************************ * Everything's OK, save the new value entered. ************************************************************************/ *mmNumDims = newNumDims; for (dimN = 0; dimN < newNumDims; dimN++) { mmIndices[dimN] = newIndices[dimN]; } Item->filterSetting = TRUE; opt.overallFilter = TRUE; break; } /************************************************************************** * Variable. **************************************************************************/ case VARIABLEt: { void *newValue; long numElems; void **mmPtr = BOO(min,&(Item->Var->min),&(Item->Var->max)); void **mmPtrX = BOO(min,&(Item->Var->max),&(Item->Var->min)); /************************************************************************ * Set initial value. ************************************************************************/ if (*mmPtr == NULL) strcpyX (value, BOO(STRINGdataType(Item->Var->dataType),"\"\"",""), 0); else EncodeValuesFormat (Item->Var->dataType, Item->Var->numElems, *mmPtr, value, NULL, 0, MAXminMaxLEN, opt.epochStyle); /************************************************************************ * Prompt for new value. ************************************************************************/ if (!PromptFor(value,MAXminMaxLEN, strlen(value) - BOO(STRINGdataType(Item->Var->dataType),1,0), BOO(min,"Enter new minimum value...", "Enter new maximum value..."), MINmaxVALUEhelpID)) { return FALSE; } /************************************************************************ * Entering nothing erases the current value. ************************************************************************/ if (NULstring(value)) { if (*mmPtr != NULL) { cdf_FreeMemory (*mmPtr, FatalError); *mmPtr = NULL; if (*mmPtrX == NULL) Item->filterSetting = FALSE; return TRUE; } else return FALSE; } /************************************************************************ * Decode/validate the value entered. ************************************************************************/ if (!DecodeValues(value,Item->Var->dataType, &numElems,&newValue,opt.epochStyle)) { DisplayMessage ("Error decoding value.", BEEPWAIT1); return FALSE; } if (numElems != Item->Var->numElems) { DisplayMessage ("Wrong number of elements.", BEEPWAIT1); cdf_FreeMemory (newValue, FatalError); return FALSE; } /************************************************************************ * Make sure the new minimum is not greater than the current maximum. ************************************************************************/ if (min && Item->Var->max != NULL) { if (GTx(newValue,Item->Var->max, Item->Var->dataType,Item->Var->numElems)) { DisplayMessage (minGTmaxMsg, BEEPWAIT1); cdf_FreeMemory (newValue, FatalError); return FALSE; } } /************************************************************************ * Make sure the new maximum is not less than the current minimum. ************************************************************************/ if (!min && Item->Var->min != NULL) { if (LTx(newValue,Item->Var->min, Item->Var->dataType,Item->Var->numElems)) { DisplayMessage (maxLTminMsg, BEEPWAIT1); cdf_FreeMemory (newValue, FatalError); return FALSE; } } /************************************************************************ * Everything's OK, save the new value entered. ************************************************************************/ if (*mmPtr == NULL) *mmPtr = cdf_AllocateMemory (Item->Var->nValueBytes, FatalError); memmove (*mmPtr, newValue, Item->Var->nValueBytes); cdf_FreeMemory (newValue, FatalError); Item->filterSetting = TRUE; opt.overallFilter = TRUE; break; } } return TRUE; } /****************************************************************************** * PromptForFill. ******************************************************************************/ Logical PromptForFill (Var) struct VarStruct *Var; { static char value[MAXfillLEN+1]; void *newValue; long numElems; /**************************************************************************** * Set initial value. ****************************************************************************/ if (Var->fill == NULL) strcpyX (value, BOO(STRINGdataType(Var->dataType),"\"\"",""), 0); else EncodeValuesFormat (Var->dataType, Var->numElems, Var->fill, value, NULL, 0, MAXfillLEN, opt.epochStyle); /**************************************************************************** * Prompt for new value. ****************************************************************************/ if (!PromptFor(value,MAXfillLEN, strlen(value) - BOO(STRINGdataType(Var->dataType),1,0), "Enter new fill value...",FILLhelpID)) { return FALSE; } /**************************************************************************** * Check if nothing entered. ****************************************************************************/ if (NULstring(value)) { if (Var->fill != NULL) { cdf_FreeMemory (Var->fill, FatalError); Var->fill = NULL; return TRUE; } else return FALSE; } /**************************************************************************** * Decode/validate value. ****************************************************************************/ if (!DecodeValues(value,Var->dataType, &numElems,&newValue,opt.epochStyle)) { DisplayMessage ("Error decoding value.", BEEPWAIT1); return FALSE; } if (numElems != Var->numElems) { DisplayMessage ("Illegal number of elements.", BEEPWAIT1); cdf_FreeMemory (newValue, FatalError); return FALSE; } /**************************************************************************** * Save new value. ****************************************************************************/ if (Var->fill == NULL) { Var->fill = cdf_AllocateMemory (Var->nValueBytes, FatalError); } memmove (Var->fill, newValue, Var->nValueBytes); cdf_FreeMemory (newValue, FatalError); opt.useFills = TRUE; return TRUE; } /****************************************************************************** * PromptForWidth. ******************************************************************************/ Logical PromptForWidth (Item) struct ItemStruct *Item; { static char value[MAXwidthLEN+1]; int newWidth; /**************************************************************************** * Set initial value. ****************************************************************************/ sprintf (value, "%d", Item->width); /**************************************************************************** * Prompt for new value. ****************************************************************************/ if (!PromptFor(value,MAXwidthLEN,strlen(value), "Enter new width...",WIDTHhelpID)) return FALSE; /**************************************************************************** * Check if nothing entered. ****************************************************************************/ if (NULstring(value)) return FALSE; /**************************************************************************** * Decode/validate value. ****************************************************************************/ if (sscanf(value,"%d",&newWidth) != 1) { DisplayMessage ("Error decoding width.", BEEPWAIT1); return FALSE; } if (newWidth < 0) { DisplayMessage ("Illegal width.", BEEPWAIT1); return FALSE; } /**************************************************************************** * Save new width. ****************************************************************************/ Item->width = newWidth; return TRUE; } /****************************************************************************** * PromptForReserve. ******************************************************************************/ Logical PromptForReserve (Var) struct VarStruct *Var; { static char value[MAXreserveLEN+1]; long newReserve; /**************************************************************************** * Set initial value. ****************************************************************************/ sprintf (value, "%ld", Var->reserve); /**************************************************************************** * Prompt for new value. ****************************************************************************/ if (!PromptFor(value,MAXreserveLEN,strlen(value), "Enter new reserve percentage...", RESERVEhelpID)) return FALSE; /**************************************************************************** * Check if nothing entered. ****************************************************************************/ if (NULstring(value)) return FALSE; /**************************************************************************** * Decode/validate value. ****************************************************************************/ if (sscanf(value,"%ld",&newReserve) != 1) { DisplayMessage ("Error decoding reserve percentage.", BEEPWAIT1); return FALSE; } if (newReserve < 0) { DisplayMessage ("Illegal reserve percentage.", BEEPWAIT1); return FALSE; } /**************************************************************************** * Save new reserve. ****************************************************************************/ Var->reserve = newReserve; return TRUE; } /****************************************************************************** * PromptForBlocking. ******************************************************************************/ Logical PromptForBlocking (Var) struct VarStruct *Var; { static char value[MAXblockingLEN+1]; long newBlocking; /**************************************************************************** * Set initial value. ****************************************************************************/ sprintf (value, "%ld", Var->blocking); /**************************************************************************** * Prompt for new value. ****************************************************************************/ if (!PromptFor(value,MAXblockingLEN,strlen(value), "Enter new blocking factor...",BLOCKINGhelpID)) return FALSE; /**************************************************************************** * Check if nothing entered. ****************************************************************************/ if (NULstring(value)) return FALSE; /**************************************************************************** * Decode/validate value. ****************************************************************************/ if (sscanf(value,"%ld",&newBlocking) != 1) { DisplayMessage ("Error decoding blocking factor.", BEEPWAIT1); return FALSE; } if (newBlocking < 0) { DisplayMessage ("Illegal blocking factor.", BEEPWAIT1); return FALSE; } /**************************************************************************** * Save new blocking factor. ****************************************************************************/ Var->blocking = newBlocking; return TRUE; } /****************************************************************************** * PromptForFormat. ******************************************************************************/ Logical PromptForFormat (Item) struct ItemStruct *Item; { char format[MAXitemFieldLEN+1]; /**************************************************************************** * Set initial format. ****************************************************************************/ strcpyX (format, BOO(Item->Var->format == NULL,"",Item->Var->format), MAXitemFieldLEN); /**************************************************************************** * Prompt for new format. ****************************************************************************/ if (!PromptFor(format,MAXitemFieldLEN,strlen(format), "Enter new format...",FORMAThelpID)) return FALSE; /**************************************************************************** * Check if nothing entered. ****************************************************************************/ if (NULstring(format)) { if (Item->Var->format != NULL) { cdf_FreeMemory (Item->Var->format, FatalError); Item->Var->format = NULL; return TRUE; } else return FALSE; } /**************************************************************************** * Decode/validate new format? ****************************************************************************/ if (!ValidFormat(format)) { DisplayMessage ("Illegal format specification.", BEEPWAIT1); return FALSE; } /**************************************************************************** * Save new format. ****************************************************************************/ if (Item->Var->format != NULL) cdf_FreeMemory (Item->Var->format, FatalError); Item->Var->format = (char *) cdf_AllocateMemory (strlen(format) + 1, FatalError); strcpyX (Item->Var->format, format, 0); /**************************************************************************** * Possibly increase width based on new format. ****************************************************************************/ Item->width = MaxInt(Item->width,VariableWidth(Item->Var)); /**************************************************************************** * Return success. ****************************************************************************/ return TRUE; } /****************************************************************************** * PromptForCompression. ******************************************************************************/ Logical PromptForCompression (cType, cParms) long *cType; long cParms[CDF_MAX_PARMS]; { static Logical first = TRUE; static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL }; AOSs1 (iLines, "None RLE.0 HUFF.0 AHUFF.0 GZIP...") static int iLineNs[] = { 0,0,0,0,0 }; static int iCols[] = { 0,7,15,24,34 }; static int iLens[] = { 4,5,6,7,7 }; static struct ItemWindowStruct IW = { 21, 0, 80, " Select new compression... ", 0, NULL, 1, iLines, 5, iLineNs, iCols, iLens, 1, 0, NULL, exitChars, REFRESHkey_FSI, FALSE, NUL, NUL }; static char keyDefs[] = { "Enter: ________ Help: ________ Exit: ________\n\n" }; static char keyDefsBlank[] = ""; if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); first = FALSE; } NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (NEWiw, &IW, 0); NEWkeyDEFS (EWkey, keyDefs, batchMode) for (;;) { ItemWindow (READiw, &IW); switch (IW.key) { case ENTERkey_FSI: switch (IW.itemN) { case NONEin: *cType = NO_COMPRESSION; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return TRUE; case RLE0in: *cType = RLE_COMPRESSION; cParms[0] = RLE_OF_ZEROs; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return TRUE; case HUFF0in: *cType = HUFF_COMPRESSION; cParms[0] = OPTIMAL_ENCODING_TREES; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return TRUE; case AHUFF0in: *cType = AHUFF_COMPRESSION; cParms[0] = OPTIMAL_ENCODING_TREES; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return TRUE; case GZIPin: { Logical done = FALSE; static char token[MAX_GZIP_TOKEN_LEN+1] = "GZIP."; static int gzipExit[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL }; static struct PromptWindowStruct PW = { "Enter GnuZIP compression parameters...", 21, 0, 80, 0, NULL, MAX_GZIP_TOKEN_LEN, token, 0, NULL, gzipExit, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI }; ItemWindow (UNDISPLAYiw, &IW); PromptWindow (NEWpw, &PW, (int) strlen(PW.value), LogicalTRUE); while (!done) { PromptWindow (READpw, &PW); switch (PW.key) { case ENTERkey_FSI: { int level; if (sscanf(PW.value,"GZIP.%d",&level) == 1) { if (INCLUSIVE(1,level,9)) { *cType = GZIP_COMPRESSION; cParms[0] = level; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) PromptWindow (DELETEpw, &PW); ItemWindow (DELETEiw, &IW); return TRUE; } } PromptWindow (UNDISPLAYpw, &PW); DisplayMessage ("Illegal GZIP parameters.", BEEPWAIT1); PromptWindow (REDISPLAYpw, &PW); break; } case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", GZIPhelpID); break; case EXITkey_FSI: PromptWindow (DELETEpw, &PW); ItemWindow (REDISPLAYiw, &IW); done = TRUE; break; } } break; } } break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", COMPRESShelpID); break; case EXITkey_FSI: NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return FALSE; } } } /****************************************************************************** * PromptForChecksum. ******************************************************************************/ Logical PromptForChecksum (checksum) long *checksum; { static Logical first = TRUE; static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL }; AOSs1 (iLines, "None MD5") static int iLineNs[] = { 0,0 }; static int iCols[] = { 0,7 }; static int iLens[] = { 4,3 }; static struct ItemWindowStruct IW = { 21, 0, 80, " Select new checksum... ", 0, NULL, 1, iLines, 2, iLineNs, iCols, iLens, 1, 0, NULL, exitChars, REFRESHkey_FSI, FALSE, NUL, NUL }; static char keyDefs[] = { "Enter: ________ Help: ________ Exit: ________\n\n" }; static char keyDefsBlank[] = ""; if (first) { char *p1 = keyDefs; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); first = FALSE; } NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (NEWiw, &IW, 0); NEWkeyDEFS (EWkey, keyDefs, batchMode) for (;;) { ItemWindow (READiw, &IW); switch (IW.key) { case ENTERkey_FSI: switch (IW.itemN) { case NONEin: *checksum = NO_CHECKSUM; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return TRUE; case MD5in: *checksum = MD5_CHECKSUM; NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return TRUE; } break; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", CHECKSUMhelpID); break; case EXITkey_FSI: NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) ItemWindow (DELETEiw, &IW); return FALSE; } } } /****************************************************************************** * PromptForSparseness. ******************************************************************************/ Logical PromptForSparseness (Var) struct VarStruct *Var; { static Logical first = TRUE; static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL }; AOSs1 (iLines, "sRecords.NO sRecords.PAD sRecords.PREV") static int iLineNs[] = { 0,0,0 }; static int iCols[] = { 0,16,33 }; static int iLens[] = { 11,12,13 }; static struct ItemWindowStruct IW = { 21, 0, 80, " Select new sparseness... ", 0, NULL, 1, iLines, 3, iLineNs, iCols, iLens, 1, 0, NULL, exitChars, REFRESHkey_FSI, FALSE, NUL, NUL }; static char keyDefsPrompt[] = { "Enter: ________ Help: ________ Exit: ________\n\n" }; static char keyDefsBlank[] = ""; if (first) { char *p1 = keyDefsPrompt; EncodeKeyDefinitions (1, &p1, ENTERkey_FSI, HELPkey_FSI, EXITkey_FSI); first = FALSE; } ItemWindow (NEWiw, &IW, 0); NEWkeyDEFS (EWkey, keyDefsPrompt, batchMode) for (;;) { ItemWindow (READiw, &IW); switch (IW.key) { case ENTERkey_FSI: switch (IW.itemN) { case NOsRECORDSin: Var->sRecordsType = NO_SPARSERECORDS; break; case PADsRECORDSin: Var->sRecordsType = PAD_SPARSERECORDS; break; case PREVsRECORDSin: Var->sRecordsType = PREV_SPARSERECORDS; break; } ItemWindow (DELETEiw, &IW); NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) return TRUE; case HELPkey_FSI: OnlineHelpWindow ("cdfxp.ilh", SPARSEhelpID); break; case EXITkey_FSI: ItemWindow (DELETEiw, &IW); NEWkeyDEFS (EWkey, keyDefsBlank, batchMode) return FALSE; } } } /****************************************************************************** * FlipItems. ******************************************************************************/ Logical FlipItems (itemX) int itemX; { struct ItemStruct *Item = itemHead, *prevItem = NULL, *tItem; int itemXt; /**************************************************************************** * Locate Item (and previous Item) to be flipped. ****************************************************************************/ for (itemXt = 0; itemXt < itemX; itemXt++) { prevItem = Item; Item = Item->nextItem; } /**************************************************************************** * Check if only one Item. ****************************************************************************/ if (Item == itemHead && Item->nextItem == NULL) return FALSE; /**************************************************************************** * Check if last Item. ****************************************************************************/ if (Item->nextItem == NULL) { prevItem->nextItem = NULL; Item->nextItem = itemHead; itemHead = Item; return TRUE; } /**************************************************************************** * Check if first Item. ****************************************************************************/ if (Item == itemHead) { tItem = Item->nextItem; Item->nextItem = tItem->nextItem; tItem->nextItem = Item; itemHead = tItem; return TRUE; } /**************************************************************************** * In the middle of the Item's. ****************************************************************************/ tItem = Item->nextItem; Item->nextItem = tItem->nextItem; tItem->nextItem = Item; prevItem->nextItem = tItem; return TRUE; } /****************************************************************************** * VariableWidth. ******************************************************************************/ int VariableWidth (Var) struct VarStruct *Var; { int width; /**************************************************************************** * Check for a string data type. In this case the format is ignored. ****************************************************************************/ if (STRINGdataType(Var->dataType)) { return MaxInt(MIN_VARIABLE_WIDTH,(int)(Var->numElems+2)); } /**************************************************************************** * Check for an EPOCH data type. Depending on the style the format may be * ignored. ****************************************************************************/ if (EPOCHdataType(Var->dataType)) { switch (opt.epochStyle) { case EPOCH0_STYLE: return MAXIMUM(EPOCH_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCH1_STYLE: return MAXIMUM(EPOCH1_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCH2_STYLE: return MAXIMUM(EPOCH2_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCH3_STYLE: return MAXIMUM(EPOCH3_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCHf_STYLE: break; /* Continue on... */ case EPOCHx_STYLE: return MAXIMUM(EPOCHx_STRING_MAX,MIN_VARIABLE_WIDTH); } } /**************************************************************************** * Check for an EPOCH16 data type. Depending on the style the format may be * ignored. ****************************************************************************/ if (EPOCH16dataType(Var->dataType)) { switch (opt.epochStyle) { case EPOCH0_STYLE: return MAXIMUM(EPOCH16_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCH1_STYLE: return MAXIMUM(EPOCH16_1_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCH2_STYLE: return MAXIMUM(EPOCH16_2_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCH3_STYLE: return MAXIMUM(EPOCH16_3_STRING_LEN,MIN_VARIABLE_WIDTH); case EPOCHf_STYLE: break; /* Continue on... */ case EPOCHx_STYLE: return MAXIMUM(EPOCHx_STRING_MAX,MIN_VARIABLE_WIDTH); } } /**************************************************************************** * Check if a format exists. ****************************************************************************/ if (Var->format != NULL) { width = FormatWidth(Var->format); if (width != 0) return MAXIMUM(MIN_VARIABLE_WIDTH,width); } /**************************************************************************** * Either a format doesn't exist or is illegal. Use the default width for * the data type. ****************************************************************************/ switch (Var->dataType) { case CDF_BYTE: case CDF_INT1: width = 4; break; case CDF_UINT1: width = 3; break; case CDF_INT2: width = 6; break; case CDF_UINT2: width = 5; break; case CDF_INT4: width = 11; break; case CDF_UINT4: width = 10; break; case CDF_REAL4: case CDF_FLOAT: case CDF_REAL8: case CDF_DOUBLE: width = 12; break; case CDF_EPOCH: /* Format (C/Fortran) style. */ width = 12; break; case CDF_EPOCH16: /* Format (C/Fortran) style. */ width = 16; break; default: /* Unknown data type. */ width = 0; } return MAXIMUM(MIN_VARIABLE_WIDTH,width); } /****************************************************************************** * OptDefaults. ******************************************************************************/ void OptDefaults () { if (simpleMode) { opt.eachFilter = FORCEeachFilterSIMPLE; opt.overallFilter = FORCEoverallFilterSIMPLE; opt.useFills = FORCEfillsSIMPLE; opt.useFORMAT = DEFAULTformatSIMPLE; opt.useFILLVAL = FORCEfillvalSIMPLE; opt.useVALIDMIN = FORCEvalidminSIMPLE; opt.useVALIDMAX = FORCEvalidmaxSIMPLE; opt.useMONOTON = FORCEmonotonSIMPLE; opt.horizontalMode = DEFAULThorizontalSIMPLE; opt.showRecord = DEFAULTrecordSIMPLE; opt.showIndices = DEFAULTindicesSIMPLE; opt.outputItem = DEFAULToutputSIMPLE; opt.epochStyle = DEFAULTepochSIMPLE; opt.majority = DEFAULTmajoritySIMPLE; opt.spacing = DEFAULTspacingSIMPLE; opt.singleFile = NAsingleSIMPLE; opt.encoding = BOO(NAnetworkSIMPLE,NETWORK_ENCODING,HOST_ENCODING); opt.showFiltered = NAshowSIMPLE; opt.exclusive = NAexclusiveSIMPLE; opt.deleteExisting = NAdeleteSIMPLE; opt.preAllocate = NApreAllocateSIMPLE; opt.textHeading = DEFAULTheadingSIMPLE; } else { opt.eachFilter = DEFAULTeachFilterEXPORT; opt.overallFilter = DEFAULToverallFilterEXPORT; opt.useFills = DEFAULTfillsEXPORT; opt.useFORMAT = DEFAULTformatEXPORT; opt.useFILLVAL = DEFAULTfillvalEXPORT; opt.useVALIDMIN = DEFAULTvalidminEXPORT; opt.useVALIDMAX = DEFAULTvalidmaxEXPORT; opt.useMONOTON = DEFAULTmonotonEXPORT; opt.horizontalMode = DEFAULThorizontalEXPORT; opt.showRecord = DEFAULTrecordEXPORT; opt.showIndices = DEFAULTindicesEXPORT; opt.outputItem = DEFAULToutputEXPORT; opt.epochStyle = DEFAULTepochEXPORT; opt.majority = DEFAULTmajorityEXPORT; opt.spacing = DEFAULTspacingEXPORT; opt.singleFile = DEFAULTsingleEXPORT; opt.encoding = BOO(DEFAULTnetworkEXPORT,NETWORK_ENCODING,HOST_ENCODING); opt.showFiltered = DEFAULTshowEXPORT; opt.exclusive = DEFAULTexclusiveEXPORT; opt.deleteExisting = DEFAULTdeleteEXPORT; opt.preAllocate = DEFAULTpreAllocateEXPORT; opt.textHeading = DEFAULTheadingEXPORT; } return; }