/******************************************************************************
*
* NSSDC/CDF CDFedit, part 2 (variables).
*
* Version 1.3a, 16-Nov-97, Hughes STX.
*
* Modification history:
*
* V1.0 24-Jan-94, J Love Original version.
* V1.0a 8-Feb-94, J Love DEC Alpha/OpenVMS port.
* V1.1 15-Dec-94, J Love CDF V2.5.
* V1.1a 9-Jan-95, J Love Window positioning.
* V1.1b 23-Jan-95, J Love IRIX 6.x (64-bit).
* V1.1c 28-Feb-95, J Love Pass `char' as `int'.
* V1.2 11-Apr-95, J Love POSIX.
* V1.2a 11-May-95, J Love EPOCH styles.
* V1.2b 9-Jun-95, J Love catchrX.
* V1.2c 6-Sep-95, J Love CDFexport-related changes. FSI key
* definitions.
* V1.3 27-Aug-96, J Love CDF V2.6.
* V1.3a 16-Nov-97, J Love Windows NT/Visual C++.
* V1.3b 02-Jun-98, M Liu Minor correction at EditVarValues.
*
******************************************************************************/
#include "cdfedit.h"
/******************************************************************************
* Local function prototypes.
******************************************************************************/
static Logical ModPadValue PROTOARGs((
Logical zVar, long varN, Logical useFormat, Logical *changed
));
/******************************************************************************
* EditVars. This function handles both rVariables and zVariables.
******************************************************************************/
Logical EditVars (Z, CDFname, useFormat)
Logical Z;
char *CDFname;
Logical useFormat;
{
CDFstatus status;
long varN;
AOSs2 (header, BLANKs78, BLANKs78)
AOSs1 (trailerBrowse, "Select: ________ Exit: ________ Help: ________")
AOSs2A (trailerEdit,
"Select: ________ Create variable: ________ Help: ________",
"Exit: ________ Delete variable: ________")
static int exitCharsBrowse[] = {
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL
};
static int exitCharsEdit[] = {
ENTERkey_FSI, EXITkey_FSI, CREATEVARkey_EDIT, HELPkey_FSI,
DELETEVARkey_EDIT, NUL
};
static char label[6+DU_MAX_NAME_LEN+13+1];
static struct ItemWindowStruct IW = {
0, 0, 80, label, 2, header, 0, NULL, 0, NULL, NULL, NULL, 0, 0, NULL,
NULL, REFRESHkey_FSI, TRUE, NSkey_FSI, PSkey_FSI
};
int varJump = BOO(Z,7,6);
static Logical first = TRUE;
/***************************************************************************
* First time...
***************************************************************************/
if (first) {
EncodeKeyDefinitions (1, trailerBrowse, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
EncodeKeyDefinitions (2, trailerEdit, ENTERkey_FSI, CREATEVARkey_EDIT,
HELPkey_FSI, EXITkey_FSI, DELETEVARkey_EDIT);
first = FALSE;
}
if (browseOnly) {
IW.NiRows = 14;
IW.NtLines = 1;
IW.tLines = trailerBrowse;
IW.exitChars = exitCharsBrowse;
}
else {
IW.NiRows = 13;
IW.NtLines = 2;
IW.tLines = trailerEdit;
IW.exitChars = exitCharsEdit;
}
/***************************************************************************
* Build variable lines.
***************************************************************************/
if (!BuildVarMenu(Z,CDFname,&IW)) return FALSE;
/***************************************************************************
* Display window.
***************************************************************************/
ItemWindow (NEWiw, &IW, 0);
/***************************************************************************
* Read/process keystrokes until request to exit menu.
***************************************************************************/
for (;;) {
ItemWindow (READiw, &IW);
switch (IW.key) {
/***********************************************************************
* Item selected.
***********************************************************************/
case ENTERkey_FSI: {
int fieldN;
/*********************************************************************
* Check if any variables exist.
*********************************************************************/
if (IW.nItems == 0) {
ProblemWindow (BOO(Z,"Nothing selected (no zVariables exist).",
"Nothing selected (no rVariables exist)."),
FALSE);
break;
}
/*********************************************************************
* Calculate variable number and field number.
*********************************************************************/
fieldN = IW.itemN % varJump;
varN = IW.itemN / varJump;
/*********************************************************************
* Modify/show variable name.
*********************************************************************/
if (fieldN == 0) {
char varName[CDF_VAR_NAME_LEN256+1];
status = CDFlib (SELECT_, VAR(Z), varN,
GET_, VAR_NAME(Z), varName,
NULL_);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (browseOnly)
ShowFullName (varName, FALSE);
else {
static char *header[] = {
"Enter new name (with delimiters)...",
"Syntax: <delim><char1><char2>...<charN><delim>",
"Example: \"SeaSurfaceTemperature\""
};
AOSs1 (trailer,"Enter: ________ Exit: ________ Help: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NUL };
static char value[1+CDF_VAR_NAME_LEN256+1+1]; char delim;
static char label[14+CDF_VAR_NAME_LEN256+1];
static struct PromptWindowStruct PW = {
label, 4, 1, 78, 3, header, CDF_VAR_NAME_LEN256+2, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI,
INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
delim = PickDelimiter(varName, strlen(varName));
sprintf (value, "%c%s%c", delim, varName, delim);
sprintf (label, " %cVariable %c%s%c ", BOO(Z,'z','r'),
delim, varName, delim);
PromptWindow (NEWpw, &PW, (int) (strlen(PW.value) - 1),
LogicalTRUE);
for (;;) {
if (EnterPW(&PW,VARRENAMEhelpID)) {
char varName[CDF_VAR_NAME_LEN256+1];
if (DecodeDelimitedString(PW.value,varName)) {
status = CDFlib (PUT_, VAR_NAME(Z), varName,
NULL_);
if (ReportStatus(status,FALSE)) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
ProblemWindow ("Illegal name (check delimiters).", FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PW);
}
break;
}
/*********************************************************************
* Modify data specification (data type and number of elements).
*********************************************************************/
if (fieldN == 1) {
if (browseOnly)
ItemWindow (BEEPiw, &IW);
else {
long numElems, dataType; static char label[14+CDF_VAR_NAME_LEN256+1];
char varName[CDF_VAR_NAME_LEN256+1], delim;
status = CDFlib (SELECT_, VAR(Z), varN,
GET_, VAR_NAME(Z), varName,
VAR_DATATYPE(Z), &dataType,
NULL_);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
delim = PickDelimiter(varName, strlen(varName));
sprintf (label, " %cVariable %c%s%c ", BOO(Z,'z','r'),
delim, varName, delim);
if (SelectDataSpec(&dataType,&numElems,label)) {
status = CDFlib (PUT_, VAR_DATASPEC(Z), dataType, numElems,
NULL_);
if (ReportStatus(status,FALSE)) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
else {
if (NoMoreAccess(NULL)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
}
}
break;
}
/*********************************************************************
* Dimensionality field.
*********************************************************************/
if (Z && fieldN == 2) {
ItemWindow (BEEPiw, &IW);
break;
}
/*********************************************************************
* Modify variances.
*********************************************************************/
if (fieldN == BOO(Z,3,2)) {
if (browseOnly)
ItemWindow (BEEPiw, &IW);
else {
long numDims;
long recVary, dimVarys[CDF_MAX_DIMS];
static char *header[] = {
"Enter variances...",
"Syntax: <recVary>/<dimVary1><dimVary2>...<dimVaryN>",
"Examples: T/, T/F, F/TF, T/TTT"
};
AOSs1 (trailer,"Enter: ________ Exit: ________ Help: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NUL };
static char value[2+CDF_MAX_DIMS+1];
static char label[14+CDF_VAR_NAME_LEN256+1];
static struct PromptWindowStruct PW = {
label, 4, 1, 78, 3, header, 0, value, 1, trailer, exitChars,
REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI,
INSERTorOVERkey_FSI
};
char varName[CDF_VAR_NAME_LEN256+1], delim;
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
status = CDFlib (SELECT_, VAR(Z), varN,
GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
VAR_RECVARY(Z), &recVary,
VAR_DIMVARYS(Z), dimVarys,
VAR_NAME(Z), varName,
NULL_);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
PW.maxChars = (int) (2 + numDims);
EncodeVariances (PW.value, recVary, numDims, dimVarys);
delim = PickDelimiter(varName, strlen(varName));
sprintf (label, " %cVariable %c%s%c ", BOO(Z,'z','r'),
delim, varName, delim);
PromptWindow (NEWpw, &PW, (int) strlen(PW.value), LogicalTRUE);
for (;;) {
if (EnterPW(&PW,VARVARYShelpID)) {
if (DecodeVariances(PW.value,numDims,&recVary,dimVarys)) {
status = CDFlib (PUT_, VAR_RECVARY(Z), recVary,
VAR_DIMVARYS(Z), dimVarys,
NULL_);
if (ReportStatus(status,FALSE)) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
ProblemWindow ("Illegal variances.", FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PW);
}
break;
}
/*********************************************************************
* View/modify attribute entries.
*********************************************************************/
if (fieldN == BOO(Z,4,3)) {
ItemWindow (UNDISPLAYiw, &IW);
if (!EditVarEntries(Z,varN,(long)IW.NiLines)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (REDISPLAYiw, &IW);
break;
}
/*********************************************************************
* View/modify values.
*********************************************************************/
if (fieldN == BOO(Z,5,4)) {
Logical changed = FALSE;
ItemWindow (UNDISPLAYiw, &IW);
if (!EditVarValues(Z,varN,(long)IW.NiLines,useFormat,&changed)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (changed) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
ItemWindow (REDISPLAYiw, &IW);
break;
}
/*********************************************************************
* More...
*********************************************************************/
if (fieldN == BOO(Z,6,5)) {
Logical changed = FALSE;
long nVars = IW.nItems / varJump;
ItemWindow (UNDISPLAYiw, &IW);
if (!EditVarMore(Z,varN,useFormat,&changed,nVars)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (changed) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
ItemWindow (REDISPLAYiw, &IW);
break;
}
break;
}
/***********************************************************************
* Create variable. If variable is successfully created, the current
* item is set to its name field.
***********************************************************************/
case CREATEVARkey_EDIT: {
Logical created;
if (!CreateVar(Z,&created)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (created) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.nItems - varJump);
}
break;
}
/***********************************************************************
* Delete variable.
* If variable is successfully deleted, the current item is set to...
***********************************************************************/
case DELETEVARkey_EDIT: {
char varName[CDF_VAR_NAME_LEN256+1], delim,
question[21+CDF_VAR_NAME_LEN256+1];
if (IW.nItems == 0) {
ProblemWindow (BOO(Z,"Nothing selected (no zVariables exist).",
"Nothing selected (no rVariables exist)."),
FALSE);
break;
}
varN = IW.itemN / varJump;
status = CDFlib (SELECT_, BOO(Z,zVAR_,rVAR_), varN,
GET_, BOO(Z,zVAR_NAME_,rVAR_NAME_), varName,
NULL_);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
delim = PickDelimiter (varName, strlen(varName));
sprintf (question, "Delete %sVariable %c%s%c ?",
BOO(Z,"z","r"), delim, varName, delim);
if (ConfirmWindow(4,78,question,NULL,FALSE,DELETEVARhelpID)) {
status = CDFlib (DELETE_, BOO(Z,zVAR_,rVAR_),
NULL_);
if (ReportStatus(status,FALSE)) {
FreeIW (&IW, FatalError);
if (!BuildVarMenu(Z,CDFname,&IW)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, 0);
}
else {
if (NoMoreAccess(NULL)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
}
break;
}
/***********************************************************************
* Display online help.
***********************************************************************/
case HELPkey_FSI:
OnlineHelpWindow (ilhFile, BOO(Z,ZVARShelpID,RVARShelpID));
break;
/***********************************************************************
* Exit menu.
***********************************************************************/
case EXITkey_FSI:
ItemWindow (DELETEiw, &IW);
FreeIW (&IW, FatalError);
return TRUE;
}
}
}
/******************************************************************************
* BuildVarMenu.
******************************************************************************/
Logical BuildVarMenu (Z, CDFname, IW)
Logical Z;
char *CDFname;
struct ItemWindowStruct *IW;
{
CDFstatus status;
long nVars, varN, dataType, numElems, maxRec, nRecords;
long recVary, dimVarys[CDF_MAX_DIMS];
long numDims, dimSizes[CDF_MAX_DIMS];
int curCol, dimN, curItem;
char varName[CDF_VAR_NAME_LEN256+1], field[80+1];
AOSs2 (loadingLines, "Loading menu...", "")
/***************************************************************************
* Determine number of variables.
***************************************************************************/
status = CDFlib (GET_, BOO(Z,CDF_NUMzVARS_,CDF_NUMrVARS_), &nVars,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
if (nVars > MANY_VARs) MessageWindow (loadingLines, NULL, LogicalFALSE);
/***************************************************************************
* Encode label/header.
***************************************************************************/
status = CDFlib (GET_, VARs_MAXREC(Z), &maxRec,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
nRecords = maxRec + 1;
sprintf (IW->label, " CDF \"%s\" %cVariables ", CDFname, BOO(Z,'z','r'));
if (Z) {
sprintf (IW->hLines[0], "%ld zVariable%s, ", nVars,
(nVars == 1 ? "" : "s"));
sprintf (&(IW->hLines[0][strlen(IW->hLines[0])]),
"(maximum of %ld zRecord%s)", nRecords,
(nRecords == 1 ? "" : "s"));
strcpyX (IW->hLines[1],
"Name DataSpec Dimensions Varys", 0);
}
else {
status = CDFlib (GET_, rVARs_NUMDIMS_, &numDims,
rVARs_DIMSIZES_, dimSizes,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
sprintf (IW->hLines[0], "%ld rVariable%s, ", nVars,
(nVars == 1 ? "" : "s"));
EncodeDimensionality (&(IW->hLines[0][strlen(IW->hLines[0])]), numDims,
dimSizes);
strcatX (IW->hLines[0], " dimensionality, ", 0);
sprintf (&(IW->hLines[0][strlen(IW->hLines[0])]), "%ld rRecord%s",
nRecords, (nRecords == 1 ? "" : "s"));
strcpyX (IW->hLines[1], "Name DataSpec Varys", 0);
}
/***************************************************************************
* Allocate item section control/lines.
***************************************************************************/
AllocIW (IW, (int) (nVars * BOO(Z,7,6)), (int) nVars, 80, FatalError);
/***************************************************************************
* Build each variable line.
***************************************************************************/
curItem = 0;
for (varN = 0; varN < nVars; varN++) {
/************************************************************************
* Inquire variable.
************************************************************************/
status = CDFlib (SELECT_, VAR(Z), varN,
GET_, VAR_NAME(Z), varName,
VAR_DATATYPE(Z), &dataType,
VAR_NUMELEMS(Z), &numElems,
VAR_RECVARY(Z), &recVary,
VAR_DIMVARYS(Z), dimVarys,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
if (Z) {
status = CDFlib (GET_, zVAR_NUMDIMS_, &numDims,
zVAR_DIMSIZES_, dimSizes,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
}
/************************************************************************
* Setup variable name.
************************************************************************/
curCol = 0;
EncodeString (strlen(varName), varName, field, 0, VARNAME_FIELD_LEN);
strcpyX (IW->iLines[(int)varN], field, 0);
if (strlen(field) < (size_t) VARNAME_FIELD_LEN) {
CatNcharacters (IW->iLines[(int)varN],
VARNAME_FIELD_LEN - strlen(field), (int) ' ');
}
CatNcharacters (IW->iLines[(int)varN], VARNAME_FIELD_BLANKS, (int) ' ');
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen(field);
curCol += VARNAME_FIELD_LEN + VARNAME_FIELD_BLANKS;
curItem++;
/************************************************************************
* Setup data type & number of elements.
************************************************************************/
strcpyX (field, DataTypeToken(dataType), 0);
catchrX (field, (int) '/', 0);
sprintf (&field[strlen(field)], "%ld", numElems);
if (strlen(field) > (size_t) DATASPEC_FIELD_LEN) {
strcpyX (field + DATASPEC_FIELD_LEN - 3, "...", 0);
}
strcatX (IW->iLines[(int)varN], field, 0);
if (strlen(field) < (size_t) DATASPEC_FIELD_LEN) {
CatNcharacters (IW->iLines[(int)varN],
DATASPEC_FIELD_LEN - strlen(field), (int) ' ');
}
CatNcharacters (IW->iLines[(int)varN], DATASPEC_FIELD_BLANKS, (int) ' ');
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen(field);
curCol += DATASPEC_FIELD_LEN + DATASPEC_FIELD_BLANKS;
curItem++;
/************************************************************************
* If Z variable, setup dimensionality.
************************************************************************/
if (Z) {
sprintf (field, "%ld:[", numDims);
for (dimN = 0; dimN < numDims; dimN++) {
sprintf (&field[strlen(field)], "%s%ld",
(dimN == 0 ? "" : ","), dimSizes[dimN]);
}
catchrX (field, (int) ']', 0);
if (strlen(field) > (size_t) DIMENSIONS_FIELD_LEN) {
strcpyX (field + DIMENSIONS_FIELD_LEN - 3, "...", 0);
}
strcatX (IW->iLines[(int)varN], field, 0);
if (strlen(field) < (size_t) DIMENSIONS_FIELD_LEN) {
CatNcharacters (IW->iLines[(int)varN],
DIMENSIONS_FIELD_LEN - strlen(field), (int) ' ');
}
CatNcharacters (IW->iLines[(int)varN], DIMENSIONS_FIELD_BLANKS,
(int) ' ');
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen (field);
curCol += DIMENSIONS_FIELD_LEN + DIMENSIONS_FIELD_BLANKS;
curItem++;
}
/************************************************************************
* Setup variances.
************************************************************************/
sprintf (field, "%s/", TFvarianceToken(recVary));
for (dimN = 0; dimN < numDims; dimN++) {
strcatX (field, TFvarianceToken(dimVarys[dimN]), 0);
}
if (strlen(field) > (size_t) VARIANCES_FIELD_LEN) {
strcpyX (field + VARIANCES_FIELD_LEN - 3, "...", 0);
}
strcatX (IW->iLines[(int)varN], field, 0);
if (strlen(field) < (size_t) VARIANCES_FIELD_LEN) {
CatNcharacters (IW->iLines[(int)varN],
VARIANCES_FIELD_LEN - strlen(field), (int) ' ');
}
CatNcharacters (IW->iLines[(int)varN], VARIANCES_FIELD_BLANKS, (int)' ');
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen (field);
curCol += VARIANCES_FIELD_LEN + VARIANCES_FIELD_BLANKS;
curItem++;
/************************************************************************
* Setup "entries" item.
************************************************************************/
if (!Z) {
CatNcharacters (IW->iLines[(int)varN],
DIMENSIONS_FIELD_LEN + DIMENSIONS_FIELD_BLANKS,
(int) ' ');
curCol += DIMENSIONS_FIELD_LEN + DIMENSIONS_FIELD_BLANKS;
}
strcpyX (field, (Z ? "<zEntries>" : "<rEntries>"), 0);
strcatX (IW->iLines[(int)varN], field, 0);
CatNcharacters (IW->iLines[(int)varN], 1, (int) ' ');
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen(field);
curCol += strlen(field) + 1;
curItem++;
/************************************************************************
* Setup "values" item.
************************************************************************/
strcpyX (field, "<values>", 0);
strcatX (IW->iLines[(int)varN], field, 0);
CatNcharacters (IW->iLines[(int)varN], 1, (int) ' ');
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen (field);
curCol += strlen(field) + 1;
curItem++;
/************************************************************************
* Setup "more" item.
************************************************************************/
strcpyX (field, "<more>", 0);
strcatX (IW->iLines[(int)varN], field, 0);
IW->iLineNs[curItem] = (int) varN;
IW->iCols[curItem] = curCol;
IW->iLens[curItem] = strlen(field);
curItem++;
}
if (nVars > MANY_VARs) MessageWindow (NULL);
return TRUE;
}
/******************************************************************************
* EditVarValues.
******************************************************************************/
Logical EditVarValues (Z, varNum, nVars, useFormat, changed)
Logical Z;
long varNum;
long nVars;
Logical useFormat;
Logical *changed; /* Assumed to be initialized to FALSE by caller. */
{
CDFstatus status; size_t nBytes; Logical overflow, done;
long dataType, numElems, numDims, dimSizes[CDF_MAX_DIMS], recVary;
long dimVarys[CDF_MAX_DIMS], indices[CDF_MAX_DIMS], recNum, maxRec;
long cType, cParms[CDF_MAX_PARMS], cPct;
int dimN; void *binary; char delim, *format, varName[CDF_VAR_NAME_LEN256];
static Logical first = TRUE;
static int vvCols[1+CDF_MAX_DIMS+1];
static int vvLens[1+CDF_MAX_DIMS+1];
static int iLineNs[1+CDF_MAX_DIMS+1] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
static char *vString;
static char vLine[MAX_SCREENLINE_LEN+1];
static char label[12+CDF_VAR_NAME_LEN256+9+1];
static char *iLines[] = { vLine };
static char *header[] = {
"Syntax: <recNum>:[<index1>,<index2>,...,<indexN>] = <value>"
};
AOSs3 (trailer,
"Select: ________ Exit: ________ Help: ________",
"Next item: ____________ Increment: ____________ Next variable: ________",
"Prev item: ____________ Decrement: ____________")
static int exitChars[] = {
ENTERkey_FSI, EXITkey_FSI, INCREMENTkey_EDIT, DECREMENTkey_EDIT,
HELPkey_FSI, NEXTVARkey_EDIT, NUL
};
static struct ItemWindowStruct IW = {
0, 0, 80, label, 1, header, 1, iLines, 0, iLineNs, vvCols, vvLens, 1,
3, trailer, exitChars, REFRESHkey_FSI, FALSE, NUL, NUL
};
/***************************************************************************
* First time...
***************************************************************************/
if (first) {
EncodeKeyDefinitions (3, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NEXTFIELDkey_EDIT, INCREMENTkey_EDIT,
NEXTVARkey_EDIT, PREVFIELDkey_EDIT,
DECREMENTkey_EDIT);
first = FALSE;
}
/***************************************************************************
* Initialize.
***************************************************************************/
MakeNUL (label);
MakeNUL (vLine);
IW.nItems = 0;
/***************************************************************************
* Display the window and until an exit is requested...
***************************************************************************/
ItemWindow (NEWiw, &IW, 0);
for (;;) {
/*************************************************************************
* Inquire the variable.
*************************************************************************/
status = CDFlib (SELECT_, VAR(Z), varNum,
GET_, VAR_NAME(Z), varName,
BOO(Z,zVAR_NUMDIMS_,rVARs_NUMDIMS_), &numDims,
BOO(Z,zVAR_DIMSIZES_,rVARs_DIMSIZES_), dimSizes,
VAR_DATATYPE(Z), &dataType,
VAR_NUMELEMS(Z), &numElems,
VAR_RECVARY(Z), &recVary,
VAR_DIMVARYS(Z), dimVarys,
VAR_COMPRESSION(Z), &cType, cParms, &cPct,
CONFIRM_, BOO(Z,zVAR_RECNUMBER_,
rVARs_RECNUMBER_), &recNum,
BOO(Z,zVAR_DIMINDICES_,
rVARs_DIMINDICES_), indices,
NULL_);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
/*************************************************************************
* Allocate needed memory buffers.
*************************************************************************/
nBytes = (size_t) (numElems * CDFelemSize(dataType));
binary = cdf_AllocateMemory (nBytes, FatalError);
nBytes = (size_t) BOO(STRINGdataType(dataType),
numElems+3,MAX_nonSTRING_VALUE_LEN);
vString = (char *) cdf_AllocateMemory (nBytes, FatalError);
/*************************************************************************
* Encode the label.
*************************************************************************/
delim = PickDelimiter (varName, strlen(varName));
sprintf (IW.label, " %cVariable %c%s%c Values ", BOO(Z,'z','r'), delim,
varName, delim);
/*************************************************************************
* Get the FORMAT attribute entry.
*************************************************************************/
if (useFormat) {
status = GetFormatEntry (Z, varNum, &format);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
format = NULL;
/*************************************************************************
* If the variable is compressed and the values actually compressed, put
* a "loading" message where the record/indices/value will be displayed.
*************************************************************************/
if (cType != NO_COMPRESSION && cPct < 100)
strcpyX (vLine, "Loading values...", MAX_SCREENLINE_LEN);
else
MakeNUL (vLine);
ItemWindow (UPDATEiw, &IW, 0);
/*************************************************************************
* Encode/display the initial record/indices/value.
*************************************************************************/
if (!BuildVarValueLine(Z,recNum,recVary,numDims,indices,
dimVarys,dataType,numElems,binary,
vString,vLine,&(IW.nItems),vvCols,
vvLens,IW.nColsTotal-2,format,&overflow)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, 0);
/*************************************************************************
* Until done with this variable...
*************************************************************************/
done = FALSE;
while (!done) {
ItemWindow (READiw, &IW);
switch (IW.key) {
/*********************************************************************
* Up or down arrow.
*********************************************************************/
case INCREMENTkey_EDIT:
case DECREMENTkey_EDIT: {
Logical increment = (IW.key == INCREMENTkey_EDIT);
/*****************************************************************
* Check for the record number. If the record variance is FALSE,
* incrementing and/or decrementing is illegal.
*****************************************************************/
if (IW.itemN == 0) {
if (recVary) {
status = CDFlib (GET_, VAR_MAXREC(Z), &maxRec,
NULL_);
if (!ReportStatus(status,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (maxRec == -1) maxRec = 0;
if (increment)
#if MAXREC_LIMIT
recNum = BOO(recNum < maxRec,recNum + 1,0);
#else
recNum++;
#endif
else
#if MAXREC_LIMIT
recNum = BOO(recNum == 0,maxRec,
BOO(recNum > maxRec,maxRec,recNum - 1));
#else
recNum = BOO(recNum == 0,maxRec,recNum - 1);
#endif
if (!BuildVarValueLine(Z,recNum,recVary,numDims,indices,
dimVarys,dataType,numElems,binary,
vString,vLine,&(IW.nItems),vvCols,vvLens,
IW.nColsTotal-2,format,&overflow)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
else
ItemWindow (BEEPiw, &IW);
break;
}
/*****************************************************************
* Check for the value (which is an error - just ring bell). The
* value is always the last item.
*****************************************************************/
if (IW.itemN == IW.nItems - 1) {
ItemWindow (BEEPiw, &IW);
break;
}
/*****************************************************************
* Must be a dimension index. Calculate which dimension was
* selected. There must be at least one dimension for this
* point to have been reached.
*****************************************************************/
dimN = IW.itemN - 1;
if (dimVarys[dimN]) {
if (increment)
indices[dimN] = (indices[dimN] + 1) % dimSizes[dimN];
else
indices[dimN] = (indices[dimN] - 1 + dimSizes[dimN]) %
dimSizes[dimN];
if (!BuildVarValueLine(Z,recNum,recVary,numDims,indices,dimVarys,
dataType,numElems,binary,vString,vLine,
&(IW.nItems),vvCols,vvLens,
IW.nColsTotal-2,format,&overflow)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
else
ItemWindow (BEEPiw, &IW);
break;
}
/*********************************************************************
* Modify key.
*********************************************************************/
case ENTERkey_FSI:
/*******************************************************************
* Check for the record number. If the record variance is FALSE, a
* modification is illegal.
*******************************************************************/
if (IW.itemN == 0) {
if (recVary) {
static char *header[] = { "Enter record number..." };
AOSs1 (trailer,
"Enter: ________ Exit: ________ Help: ________")
static char value[MAX_RECORD_NUMBER_LEN+1];
static int exitChars[] = {
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL
};
static struct PromptWindowStruct PW = {
NULL, 9, 0, 80, 1, header, MAX_RECORD_NUMBER_LEN, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
sprintf (PW.value, "%ld", recNum + 1);
PromptWindow (NEWpw, &PW, (int) strlen(PW.value), LogicalTRUE);
for (;;) {
if (EnterPW(&PW,RECNUMBERhelpID)) {
long newRecNum;
if (sscanf(PW.value,"%ld",&newRecNum) == 1) {
if (newRecNum > 0) {
recNum = newRecNum - 1;
if (!BuildVarValueLine(Z,recNum,recVary,numDims,
indices,dimVarys,dataType,
numElems,binary,vString,vLine,
&(IW.nItems),vvCols,vvLens,
IW.nColsTotal-2,
format,&overflow)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
else
ProblemWindow ("Record number out of valid range.",
FALSE);
}
else
ProblemWindow ("Error decoding record number.", FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PW);
}
else
ItemWindow (BEEPiw, &IW);
break;
}
/*****************************************************************
* Check for the value. If so, prompt for new value (unless
* browsing). The value is always the last item.
*****************************************************************/
if (IW.itemN == IW.nItems - 1) {
if (browseOnly && !overflow) {
ItemWindow (BEEPiw, &IW);
}
else {
static char *headerBrowse[] = { "Full value..." };
static char *headerNoCHAR[] = { "Enter new value..." };
static char *headerCHAR[] = {
"Enter new value (delimiters required)..."
};
AOSs1A (trailerBrowse, "Exit: ________ Help: ________")
AOSs1B (trailerEdit,
"Enter: ________ Exit: ________ Help: ________")
static int exitCharsBrowse[] = { EXITkey_FSI, HELPkey_FSI, NUL};
static int exitCharsEdit[] = {
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL
};
static struct PromptWindowStruct PW = {
NULL, 9, 0, 80, 1, NULL, 0, NULL, 1, NULL, NULL,
REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI
};
if (browseOnly) {
EncodeKeyDefinitions (1, trailerBrowse, EXITkey_FSI,
HELPkey_FSI);
PW.hLines = headerBrowse;
PW.tLines = trailerBrowse;
PW.exitChars = exitCharsBrowse;
}
else {
EncodeKeyDefinitions (1, trailerEdit, ENTERkey_FSI,
EXITkey_FSI, HELPkey_FSI);
PW.hLines = BOO(STRINGdataType(dataType),
headerCHAR,headerNoCHAR);
PW.tLines = trailerEdit;
PW.exitChars = exitCharsEdit;
}
PW.maxChars = (int) BOO(STRINGdataType(dataType),
numElems+3,MAX_nonSTRING_VALUE_LEN);
nBytes = (size_t) (PW.maxChars + 1);
PW.value = (char *) cdf_AllocateMemory (nBytes, FatalError);
strcpyX (PW.value, vString, PW.maxChars);
PromptWindow (NEWpw, &PW,
(int) BOO(STRINGdataType(dataType),
strlen(PW.value)-1,
strlen(PW.value)), LogicalTRUE);
for (;;) {
if (EnterPW(&PW,VARVALUEhelpID)) {
long nElemsEntered; void *newBinary;
if (DecodeValues(PW.value,dataType,
&nElemsEntered,&newBinary,EPOCH0_STYLE)) {
if (nElemsEntered == numElems) {
status = CDFlib (PUT_, VAR_DATA(Z), newBinary,
NULL_);
cdf_FreeMemory (newBinary, FatalError);
if (ReportStatus(status,FALSE)) {
if (!BuildVarValueLine(Z,recNum,recVary,
numDims,indices,
dimVarys,dataType,
numElems,binary,
vString,vLine,
&(IW.nItems),
vvCols, vvLens,
IW.nColsTotal-2,
format,&overflow)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
*changed = TRUE;
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else {
char tempS[MAX_MESSAGE_TEXT_LEN+1];
strcpyX (tempS, "Illegal number of elements ",
MAX_MESSAGE_TEXT_LEN);
if (nElemsEntered > numElems)
strcatX (tempS, "(too many).", MAX_MESSAGE_TEXT_LEN);
else
strcatX (tempS, "(too few).", MAX_MESSAGE_TEXT_LEN);
ProblemWindow (tempS, FALSE);
cdf_FreeMemory (newBinary, FatalError);
}
}
else
ProblemWindow ("Illegal value.", FALSE);
}
else
break;
}
cdf_FreeMemory (PW.value, FatalError);
PromptWindow (DELETEpw, &PW);
}
break;
}
/*****************************************************************
* Must be a dimension index. Calculate which dimension was
* selected. There must be at least one dimension for this point
* to have been reached.
*****************************************************************/
{
static char *header[] = { "Enter dimension index..." };
AOSs1 (trailer,
"Enter: ________ Exit: ________ Help: ________")
static char value[MAX_DIMENSION_INDEX_LEN+1];
static int exitChars[] = {
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL
};
static struct PromptWindowStruct PW = {
NULL, 9, 0, 80, 1, header, MAX_DIMENSION_INDEX_LEN, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
dimN = IW.itemN - 1;
if (dimVarys[dimN]) {
sprintf (PW.value, "%ld", indices[dimN]+1);
PromptWindow (NEWpw, &PW, (int) strlen(PW.value), LogicalTRUE);
for (;;) {
if (EnterPW(&PW,DIMINDEXhelpID)) {
long newIndex;
if (sscanf(PW.value,"%ld",&newIndex) == 1) {
if (newIndex > 0 && newIndex <= dimSizes[dimN]) {
indices[dimN] = newIndex - 1;
if (!BuildVarValueLine(Z,recNum,recVary,numDims,
indices,dimVarys,dataType,
numElems,binary,vString,vLine,
&(IW.nItems),vvCols,vvLens,
IW.nColsTotal-2,
format,&overflow)) {
PromptWindow (DELETEpw, &PW);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
else
ProblemWindow ("Dimension index out of range", FALSE);
}
else
ProblemWindow ("Error decoding dimension index.", FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PW);
}
else
ItemWindow (BEEPiw, &IW);
break;
}
/*********************************************************************
* Display online help.
*********************************************************************/
case HELPkey_FSI:
OnlineHelpWindow (ilhFile, VARVALUEShelpID);
break;
/*********************************************************************
* Next variable.
*********************************************************************/
case NEXTVARkey_EDIT:
cdf_FreeMemory (vString, FatalError);
cdf_FreeMemory (binary, FatalError);
if (format != NULL) cdf_FreeMemory (format, FatalError);
varNum = (varNum + 1) % nVars;
done = TRUE;
break;
/*********************************************************************
* Exit.
*********************************************************************/
case EXITkey_FSI:
cdf_FreeMemory (vString, FatalError);
cdf_FreeMemory (binary, FatalError);
if (format != NULL) cdf_FreeMemory (format, FatalError);
ItemWindow (DELETEiw, &IW);
return TRUE;
/*********************************************************************
* Unknown key.
*********************************************************************/
default:
ItemWindow (BEEPiw, &IW);
}
}
}
}
/******************************************************************************
* BuildVarValueLine.
******************************************************************************/
Logical BuildVarValueLine (Z, recNum, recVary, numDims, indices, dimVarys,
dataType, numElems, binary, vString, vLine, nItems,
vvCols, vvLens, nCols, format, overflow)
Logical Z;
long recNum;
long recVary;
long numDims;
long *indices;
long *dimVarys;
long dataType;
long numElems;
void *binary;
char *vString;
char *vLine;
int *nItems;
int *vvCols;
int *vvLens;
int nCols;
char *format;
Logical *overflow;
{
CDFstatus status; int dimN; Logical virtual;
static char virtualT[] = " <virtual>";
int itemN = 0, availCols;
/***************************************************************************
* Encode record number.
***************************************************************************/
vvCols[itemN] = 0;
if (recVary)
sprintf (vLine, "%ld", (long) (recNum + 1));
else
strcpyX (vLine, "*", 0);
vvLens[itemN] = strlen(vLine);
itemN++;
strcatX (vLine, ":[", 0);
/***************************************************************************
* Encode dimension indices.
***************************************************************************/
for (dimN = 0; dimN < numDims; dimN++) {
if (dimN != 0) strcatX (vLine, ",", 0);
vvCols[itemN] = strlen(vLine);
if (dimVarys[dimN])
sprintf (EofS(vLine), "%ld", (long) (indices[dimN] + 1));
else
strcpyX (EofS(vLine), "*", 0);
vvLens[itemN] = strlen (&vLine[vvCols[itemN]]);
itemN++;
}
strcatX (vLine, "] = ", 0);
/***************************************************************************
* Encode value.
***************************************************************************/
status = CDFlib (SELECT_, BOO(Z,zVAR_RECNUMBER_,rVARs_RECNUMBER_), recNum,
BOO(Z,zVAR_DIMINDICES_,
rVARs_DIMINDICES_), indices,
GET_, VAR_DATA(Z), binary,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
vvCols[itemN] = strlen(vLine);
virtual = (status == VIRTUAL_RECORD_DATA);
availCols = nCols - strlen(vLine) - BOO(virtual,strlen(virtualT),0);
*overflow = BOO(STRINGdataType(dataType),
availCols < numElems + 3,
availCols < MAX_nonSTRING_VALUE_LEN);
EncodeValuesFormat (dataType, numElems, binary, EofS(vLine), format,
-BOO(virtual,availCols,0), availCols, EPOCH0_STYLE);
if (virtual) strcatX (vLine, virtualT, 0);
vvLens[itemN] = strlen(&vLine[vvCols[itemN]]);
*nItems = itemN + 1;
EncodeValuesFormat (dataType, numElems, binary, vString, format, 0,
BOO(STRINGdataType(dataType),
(int)(numElems + 3),MAX_nonSTRING_VALUE_LEN),
EPOCH0_STYLE);
return TRUE;
}
/******************************************************************************
* EditVarMore.
******************************************************************************/
Logical EditVarMore (Z, varN, useFormat, changed, nVars)
Logical Z;
long varN;
Logical useFormat;
Logical *changed; /* Only report changes that affect the caller.
Assumed to be initialized to FALSE by caller. */
long nVars;
{
CDFstatus status; static Logical first = TRUE;
AOSs6 (header, BLANKs78, BLANKs78, BLANKs78, BLANKs78, BLANKs78, BLANKs78)
AOSs1 (trailer, "Select: ________ Exit: ________ Help: ________ Next variable: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI,
NEXTVARkey_EDIT, NUL };
static char label[12+CDF_VAR_NAME_LEN256+9+1];
static char *itemsBrowse[] = {
"<View pad value>",
"",
""
};
static char *itemsEdit[] = {
"<Modify pad value> <Modify blocking factor> <Modify sparseness>",
"<Allocate records> <Write initial records> <Modify compression>",
"<Delete records>"
};
static int iLineNsBrowse[] = { 0 };
static int iColsBrowse[] = { 0 };
static int iLensBrowse[] = { 16 };
static int iLineNsEdit[] = { 0,0,0,1,1,1,2 };
static int iColsEdit[] = { 0,19,44,0,19,43,0 };
static int iLensEdit[] = { 18,24,19,18,23,20,16 };
static struct ItemWindowStruct IW = {
0, 0, 80, label, 6, header, 3, NULL, 0, NULL, NULL, NULL, 3, 1, trailer,
exitChars, REFRESHkey_FSI, FALSE, NUL, NUL
};
/***************************************************************************
* First time...
***************************************************************************/
if (first) {
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NEXTVARkey_EDIT);
first = FALSE;
}
if (browseOnly) {
IW.iLines = itemsBrowse;
IW.nItems = 1;
IW.iLineNs = iLineNsBrowse;
IW.iCols = iColsBrowse;
IW.iLens = iLensBrowse;
}
else {
IW.iLines = itemsEdit;
IW.nItems = 7;
IW.iLineNs = iLineNsEdit;
IW.iCols = iColsEdit;
IW.iLens = iLensEdit;
}
/***************************************************************************
* Build variable `more' menu and display window.
***************************************************************************/
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,TRUE)) return FALSE;
ItemWindow (NEWiw, &IW, 0);
/***************************************************************************
* Read/process keystrokes until request to exit menu.
***************************************************************************/
for (;;) {
ItemWindow (READiw, &IW);
switch (IW.key) {
/***********************************************************************
* Item selected.
***********************************************************************/
case ENTERkey_FSI: {
switch (IW.itemN) {
/*******************************************************************
* View/modify pad value.
*******************************************************************/
case VIEWorMODIFYpadIN: {
if (!ModPadValue(Z,varN,useFormat,changed)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (*changed) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
break;
}
/*******************************************************************
* Blocking factor.
*******************************************************************/
case MODIFYblockingIN: {
static char *header[] = { "Enter blocking factor (records)..." };
AOSs1 (trailer,
"Enter: ________ Exit: ________ Help: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NUL };
static char value[MAX_nonSTRING_VALUE_LEN+1];
static struct PromptWindowStruct PWt = {
NULL, 14, 0, 80, 1, header, MAX_nonSTRING_VALUE_LEN, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
strcpyX (value, "", MAX_nonSTRING_VALUE_LEN);
PromptWindow (NEWpw, &PWt, 0, LogicalTRUE);
for (;;) {
if (EnterPW(&PWt,EXTENDRECShelpID)) {
long nRecords;
if (sscanf(PWt.value,"%ld",&nRecords) == 1) {
status = CDFlib (SELECT_, VAR(Z), varN,
PUT_, VAR_BLOCKINGFACTOR(Z), nRecords,
NULL_);
if (ReportStatus(status,FALSE)) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
ProblemWindow ("Error decoding number of records.", FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PWt);
break;
}
/*******************************************************************
* Allocate records.
*******************************************************************/
case ALLOCATErecordsIN: {
static char *header[] = {
"Enter first/last records to allocate. Examples: 1/100, 10/10"
};
AOSs1 (trailer,
"Enter: ________ Exit: ________ Help: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NUL };
static char value[MAX_nonSTRING_VALUE_LEN+1];
static struct PromptWindowStruct PWt = {
NULL, 14, 0, 80, 1, header, MAX_nonSTRING_VALUE_LEN, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
strcpyX (value, "", MAX_nonSTRING_VALUE_LEN);
PromptWindow (NEWpw, &PWt, 0, LogicalTRUE);
for (;;) {
if (EnterPW(&PWt,ALLOCATERECShelpID)) {
long firstRecN, lastRecN;
if (sscanf(PWt.value,"%ld/%ld",&firstRecN,&lastRecN) == 2) {
firstRecN -= 1;
lastRecN -= 1;
status = CDFlib (SELECT_, VAR(Z), varN,
PUT_, VAR_ALLOCATEBLOCK(Z), firstRecN,
lastRecN,
NULL_);
if (ReportStatus(status,FALSE)) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
ProblemWindow ("Error decoding first/last records.",FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PWt);
break;
}
/*******************************************************************
* Write initial records.
*******************************************************************/
case INITIALrecordsIN: {
static char *header[] = { "Enter number of initial records..." };
AOSs1 (trailer,
"Enter: ________ Exit: ________ Help: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NUL };
static char value[MAX_nonSTRING_VALUE_LEN+1];
static struct PromptWindowStruct PWt = {
NULL, 14, 0, 80, 1, header, MAX_nonSTRING_VALUE_LEN, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
strcpyX (value, "", MAX_nonSTRING_VALUE_LEN);
PromptWindow (NEWpw, &PWt, 0, LogicalTRUE);
for (;;) {
if (EnterPW(&PWt,INITIALRECShelpID)) {
long nRecords;
if (sscanf(PWt.value,"%ld",&nRecords) == 1) {
status = CDFlib (SELECT_, VAR(Z), varN,
PUT_, VAR_INITIALRECS(Z), nRecords,
NULL_);
if (ReportStatus(status,FALSE)) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
*changed = TRUE;
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
ProblemWindow ("Error decoding number of records.", FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PWt);
break;
}
/*******************************************************************
* Variable compression.
*******************************************************************/
case MODIFYcompressionIN: {
Logical changed = FALSE;
if (!SelectCompression(BOO(Z,FORzVAR,FORrVAR),14,&changed)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (changed) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
break;
}
/*******************************************************************
* Variable sparseness.
*******************************************************************/
case MODIFYsparsenessIN: {
Logical changed = FALSE;
if (!SelectSparseness(Z,&changed)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
if (changed) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
}
break;
}
/*******************************************************************
* Delete records.
*******************************************************************/
case DELETErecordsIN: {
static char *header[] = {
"Enter first/last records to delete. Examples: 1/100, 10/10"
};
AOSs1 (trailer,"Enter: ________ Exit: ________ Help: ________")
static int exitChars[] = { ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI, NUL };
static char value[MAX_nonSTRING_VALUE_LEN+1];
static struct PromptWindowStruct PWt = {
NULL, 14, 0, 80, 1, header, MAX_nonSTRING_VALUE_LEN, value,
1, trailer, exitChars, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
EncodeKeyDefinitions (1, trailer, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
strcpyX (value, "", MAX_nonSTRING_VALUE_LEN);
PromptWindow (NEWpw, &PWt, 0, LogicalTRUE);
for (;;) {
if (EnterPW(&PWt,DELETERECShelpID)) {
long firstRecN, lastRecN;
if (sscanf(PWt.value,"%ld/%ld",&firstRecN,&lastRecN) == 2) {
firstRecN -= 1;
lastRecN -= 1;
status = CDFlib (SELECT_, VAR(Z), varN,
DELETE_, VAR_RECORDS(Z), firstRecN,
lastRecN,
NULL_);
if (ReportStatus(status,FALSE)) {
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PWt);
ItemWindow (DELETEiw, &IW);
return FALSE;
}
}
else
ProblemWindow ("Error decoding first/last records.",FALSE);
}
else
break;
}
PromptWindow (DELETEpw, &PWt);
break;
}
}
break;
}
/***********************************************************************
* Online help.
***********************************************************************/
case HELPkey_FSI:
OnlineHelpWindow (ilhFile, VARMOREhelpID);
break;
/***********************************************************************
* Next variable.
***********************************************************************/
case NEXTVARkey_EDIT:
varN = (varN + 1) % nVars;
if (!BuildVarMoreMenu(Z,varN,&IW,useFormat,FALSE)) {
ItemWindow (DELETEiw, &IW);
return FALSE;
}
ItemWindow (UPDATEiw, &IW, IW.itemN);
break;
/***********************************************************************
* Exit menu.
***********************************************************************/
case EXITkey_FSI:
ItemWindow (DELETEiw, &IW);
return TRUE;
}
}
}
/******************************************************************************
* BuildVarMoreMenu.
******************************************************************************/
Logical BuildVarMoreMenu (Z, varN, IW, useFormat, center)
Logical Z;
long varN;
struct ItemWindowStruct *IW;
Logical useFormat;
Logical center; /* Center messages displayed? */
{
CDFstatus status; char varName[CDF_VAR_NAME_LEN256+1];
long dataType, numElems, maxRec, maxAllocRec, nAllocRecs, blockingFactor;
long nIndexRecords, nIndexEntries, CDFformat, nRecords, nIndexLevels;
long numDims, dimSizes[CDF_MAX_DIMS], recVary, dimVarys[CDF_MAX_DIMS];
long cType, cParms[CDF_MAX_PARMS], cPct;
long sRecordsType, sArraysType, sArraysParms[CDF_MAX_PARMS], sArraysPct;
void *padBinary; int pad, maxWidth; char *format, delim;
/****************************************************************************
* Inquire variable.
****************************************************************************/
status = CDFlib (SELECT_, VAR(Z), varN,
GET_, CDF_FORMAT_, &CDFformat,
VAR_NAME(Z), varName,
VAR_DATATYPE(Z), &dataType,
VAR_NUMELEMS(Z), &numElems,
BOO(Z,zVAR_NUMDIMS_,rVARs_NUMDIMS_), &numDims,
BOO(Z,zVAR_DIMSIZES_,rVARs_DIMSIZES_), dimSizes,
VAR_RECVARY(Z), &recVary,
VAR_DIMVARYS(Z), dimVarys,
NULL_);
if (!ReportStatus(status,center)) return FALSE;
status = CDFlib (GET_, VAR_MAXallocREC(Z), &maxAllocRec,
VAR_NUMallocRECS(Z), &nAllocRecs,
VAR_MAXREC(Z), &maxRec,
VAR_NUMRECS(Z), &nRecords,
VAR_BLOCKINGFACTOR(Z), &blockingFactor,
VAR_COMPRESSION(Z), &cType, cParms, &cPct,
VAR_SPARSERECORDS(Z), &sRecordsType,
VAR_SPARSEARRAYS(Z), &sArraysType,
sArraysParms,
&sArraysPct,
NULL_);
if (!ReportStatus(status,center)) return FALSE;
if (CDFformat == SINGLE_FILE) {
status = CDFlib (GET_, VAR_nINDEXRECORDS(Z), &nIndexRecords,
VAR_nINDEXENTRIES(Z), &nIndexEntries,
VAR_nINDEXLEVELS(Z), &nIndexLevels,
NULL_);
if (!ReportStatus(status,center)) return FALSE;
}
/****************************************************************************
* Encode label.
****************************************************************************/
delim = PickDelimiter (varName, strlen(varName));
sprintf (IW->label, " %cVariable %c%s%c `More' ", BOO(Z,'z','r'), delim,
varName, delim);
/****************************************************************************
* Encode 1st header line.
****************************************************************************/
sprintf (IW->hLines[0], " DataSpec: %s/%ld", DataTypeToken(dataType),
numElems);
pad = VAR_MORE_MENU_1st_HALF_LEN - strlen(IW->hLines[0]);
if (pad > 0) CatNcharacters (IW->hLines[0], pad, (int) ' ');
strcatX (IW->hLines[0], "Dimensionality: ", 0);
EncodeDimensionality (EofS(IW->hLines[0]), numDims, dimSizes);
strcatX (IW->hLines[0], BOO(Z," (z)"," (r)"), 0);
/****************************************************************************
* Encode 2nd header line.
****************************************************************************/
sprintf (IW->hLines[1], " Records: %ldn/%ldx", nRecords, maxRec + 1);
pad = VAR_MORE_MENU_1st_HALF_LEN - strlen(IW->hLines[1]);
if (pad > 0) CatNcharacters (IW->hLines[1], pad, (int) ' ');
strcatX (IW->hLines[1], " Variances: ", 0);
EncodeVariances (EofS(IW->hLines[1]), recVary, numDims, dimVarys);
/****************************************************************************
* Encode 3rd header line.
****************************************************************************/
sprintf (IW->hLines[2], " Blocking: %ld (record%s)", blockingFactor,
(blockingFactor == 1 ? "" : "s"));
pad = VAR_MORE_MENU_1st_HALF_LEN - strlen(IW->hLines[2]);
if (pad > 0) CatNcharacters (IW->hLines[2], pad, (int) ' ');
sprintf (EofS(IW->hLines[2]), " Allocated: %ldn/%ldx (records)",
nAllocRecs, maxAllocRec + 1);
/****************************************************************************
* Encode 4th header line.
****************************************************************************/
sprintf (IW->hLines[3], "Sparseness: %s",
SparsenessToken(sRecordsType,sArraysType,sArraysParms));
pad = VAR_MORE_MENU_1st_HALF_LEN - strlen(IW->hLines[3]);
if (pad > 0) CatNcharacters (IW->hLines[3], pad, (int) ' ');
sprintf (EofS(IW->hLines[3]), " Compression: %s",
CompressionToken(cType,cParms));
if (cType != NO_COMPRESSION && cPct > 0) {
sprintf (EofS(IW->hLines[3]), " (%ld%%)", cPct);
}
/****************************************************************************
* Encode 5th header line.
****************************************************************************/
if (useFormat) {
status = GetFormatEntry (Z, varN, &format);
if (!ReportStatus(status,center)) return FALSE;
}
else
format = NULL;
strcpyX (IW->hLines[4], " Pad value: ", 0);
padBinary = cdf_AllocateMemory ((size_t) (numElems * CDFelemSize(dataType)),
FatalError);
status = CDFlib (GET_, VAR_PADVALUE(Z), padBinary,
NULL_);
switch (status) {
case NO_PADVALUE_SPECIFIED: {
static char defaultT[] = " (default)";
maxWidth = (IW->nColsTotal - 2) -
strlen(IW->hLines[4]) -
strlen(defaultT);
EncodeValuesFormat (dataType, numElems, padBinary, EofS(IW->hLines[4]),
format, 0, maxWidth, EPOCH0_STYLE);
strcatX (IW->hLines[4], defaultT, 0);
break;
}
default:
if (!ReportStatus(status,center)) return FALSE;
maxWidth = (IW->nColsTotal - 2) - strlen(IW->hLines[4]);
EncodeValuesFormat (dataType, numElems, padBinary, EofS(IW->hLines[4]),
format, 0, maxWidth, EPOCH0_STYLE);
break;
}
cdf_FreeMemory (padBinary, FatalError);
if (format != NULL) cdf_FreeMemory (format, FatalError);
/****************************************************************************
* Encode 6th header line.
****************************************************************************/
if (CDFformat == SINGLE_FILE) {
sprintf (IW->hLines[5],
" Indexing: %ld record%s, %ld entr%s, %ld level%s",
nIndexRecords, BOO(nIndexRecords == 1,"","s"),
nIndexEntries, BOO(nIndexEntries == 1,"y","ies"),
nIndexLevels, BOO(nIndexLevels == 1,"","s"));
}
else
sprintf (IW->hLines[5], " Indexing: n/a");
return TRUE;
}
/******************************************************************************
* CreateVar.
* Returns FALSE is a fatal error is encountered - TRUE otherwise. The
* variable not being created correctly is NOT considered a fatal error (eg.,
* an illegal name could have been specified).
******************************************************************************/
Logical CreateVar (Z, created)
Logical Z;
Logical *created; /* Set to TRUE if a variable is created. */
{
CDFstatus status;
char varName[CDF_VAR_NAME_LEN256+1];
long recVary, dimVarys[CDF_MAX_DIMS];
long numDims, dimSizes[CDF_MAX_DIMS];
long dataType, numElems;
long varNum;
static char labelOthers[19+CDF_VAR_NAME_LEN256+1], delim;
AOSs1 (trailerEnter1, "Enter: ________ Exit: ________ Help: ________")
AOSs2A (trailerEnter2, "Enter: ________ Exit: ________", "Help: ________")
AOSs2 (trailerSelect2, "Select: ________ Exit: ________", "Help: ________")
static int exitCharsEnter[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI,
NUL };
static char *headerName[] = {
"Enter name (with delimiters)...",
"Syntax: <delim><char1><char2>...<charN><delim>",
"Example: \"EPOCH\""
};
static char valueName[DELIMed_VAR_NAME_LEN+1];
static char labelName[15+1];
static struct PromptWindowStruct PWname = {
labelName, 4, 1, 78, 3, headerName, 1+CDF_VAR_NAME_LEN256+1, valueName,
1, trailerEnter1, exitCharsEnter, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
static char *headerDim[] = {
"Enter dimensionality...",
"Syntax: <numDims>:[<dimSize1>,<dimSize2>,...,<dimSizeN>]",
"Examples: 0:[], 1:[5], 2:[100,200], 3:[10,20,30]"
};
static char valueDim[MAX_DIMENSIONALITY_LEN+1];
static struct PromptWindowStruct PWdim = {
labelOthers, 4, 1, 78, 3, headerDim, MAX_DIMENSIONALITY_LEN, valueDim,
1, trailerEnter1, exitCharsEnter, REFRESHkey_FSI, SOLkey_FSI,
EOLkey_FSI, INSERTorOVERkey_FSI
};
static char *headerVary[] = {
"Enter variances...",
"Syntax: <recVary>/<dimVary1><dimVary2>...<dimVaryN>",
"Examples: T/, T/F, F/TF, T/TTT"
};
static char valueVary[MAX_VARIANCES_LEN+1];
static struct PromptWindowStruct PWvary = {
labelOthers, 4, 1, 78, 3, headerVary, 0, valueVary, 1, trailerEnter1,
exitCharsEnter, REFRESHkey_FSI, SOLkey_FSI, EOLkey_FSI,
INSERTorOVERkey_FSI
};
/****************************************************************************
* Set up.
****************************************************************************/
*created = FALSE;
EncodeKeyDefinitions (1, trailerEnter1,
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI);
EncodeKeyDefinitions (2, trailerEnter2,
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI);
EncodeKeyDefinitions (2, trailerSelect2,
ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI);
/****************************************************************************
* Prompt for name.
****************************************************************************/
strcpyX (PWname.value, "\"\"", DELIMed_VAR_NAME_LEN);
sprintf (labelName, " New %cVariable ", BOO(Z,'z','r'));
PromptWindow (NEWpw, &PWname, 1, LogicalTRUE);
for (;;) {
if (EnterPW(&PWname,VARNAMEhelpID)) {
if (DecodeDelimitedString(PWname.value,varName))
break;
else
ProblemWindow ("Illegal name (check delimiters).", FALSE);
}
else {
strcpyX (varName, "", CDF_VAR_NAME_LEN256);
break;
}
}
PromptWindow (DELETEpw, &PWname);
if (strlen(varName) == 0) return TRUE;
delim = PickDelimiter (varName, strlen(varName));
sprintf (labelOthers, " New %cVariable %c%s%c ", BOO(Z,'z','r'),
delim, varName, delim);
/****************************************************************************
* Prompt for data type/number of elements.
****************************************************************************/
dataType = NO_DATATYPE;
if (!SelectDataSpec(&dataType,&numElems,labelOthers)) return TRUE;
/****************************************************************************
* If zVariable, prompt for number/sizes of dimensions. If rVariable,
* determine number of dimensions.
****************************************************************************/
if (Z) {
strcpyX (PWdim.value, "", MAX_DIMENSIONALITY_LEN);
PromptWindow (NEWpw, &PWdim, 0, LogicalTRUE);
for (;;) {
if (EnterPW(&PWdim,ZDIMhelpID)) {
if (DecodeDimensionality(PWdim.value,&numDims,dimSizes))
break;
else
ProblemWindow ("Illegal dimensionality.", FALSE);
}
else {
numDims = -1;
break;
}
}
PromptWindow (DELETEpw, &PWdim);
if (numDims == -1) return TRUE;
}
else {
status = CDFlib (GET_, rVARs_NUMDIMS_, &numDims,
rVARs_DIMSIZES_, dimSizes,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
}
/****************************************************************************
* Prompt for variances.
****************************************************************************/
PWvary.maxChars = (int) (1 + 1 + numDims);
strcpyX (PWvary.value, "", MAX_VARIANCES_LEN);
PromptWindow (NEWpw, &PWvary, 0, LogicalTRUE);
for (;;) {
if (EnterPW(&PWvary,VARVARYShelpID)) {
if (DecodeVariances(PWvary.value,numDims,&recVary,dimVarys))
break;
else
ProblemWindow ("Illegal variances.", FALSE);
}
else {
recVary = -2;
break;
}
}
PromptWindow (DELETEpw, &PWvary);
if (recVary == -2) return TRUE;
/****************************************************************************
* Create variable.
****************************************************************************/
if (Z)
status = CDFlib (CREATE_, zVAR_, varName, dataType, numElems, numDims,
dimSizes, recVary, dimVarys, &varNum,
NULL_);
else
status = CDFlib (CREATE_, rVAR_, varName, dataType, numElems, recVary,
dimVarys, &varNum,
NULL_);
if (ReportStatus(status,FALSE)) {
*created = TRUE;
return TRUE;
}
if (NoMoreAccess(NULL)) return FALSE;
return TRUE;
}
/******************************************************************************
* ModPadValue.
******************************************************************************/
static Logical ModPadValue (zVar, varN, useFormat, changed)
Logical zVar;
long varN;
Logical useFormat;
Logical *changed; /* Assumed to be initialized to FALSE by caller. */
{
long dataType, numElems; size_t nBytes; int cursorAt;
void *binary; char *format; CDFstatus status;
static char *headerBrowse[] = { "Full pad value..." };
static char *headerNoCHAR[] = { "Enter new pad value..." };
static char *headerCHAR[] = {"Enter new pad value (delimiters required)..."};
AOSs1A (trailerBrowse, "Exit: ________ Help: ________")
AOSs1B (trailerEdit, "Enter: ________ Exit: ________ Help: ________")
static int exitCharsBrowse[] = { EXITkey_FSI, HELPkey_FSI, NUL };
static int exitCharsEdit[] = { ENTERkey_FSI, EXITkey_FSI, HELPkey_FSI, NUL };
static struct PromptWindowStruct PWt = {
NULL, 14, 0, 80, 1, NULL, 0, NULL, 1, NULL, NULL, REFRESHkey_FSI,
SOLkey_FSI, EOLkey_FSI, INSERTorOVERkey_FSI
};
status = CDFlib (SELECT_, VAR(zVar), varN,
GET_, VAR_DATATYPE(zVar), &dataType,
VAR_NUMELEMS(zVar), &numElems,
NULL_);
if (!ReportStatus(status,FALSE)) return FALSE;
nBytes = (size_t) (CDFelemSize(dataType) * numElems);
binary = cdf_AllocateMemory (nBytes, FatalError);
status = CDFlib (GET_, VAR_PADVALUE(zVar), binary,
NULL_);
switch (status) {
case NO_PADVALUE_SPECIFIED:
break;
default:
if (!ReportStatus(status,FALSE)) return FALSE;
break;
}
if (browseOnly) {
EncodeKeyDefinitions (1, trailerBrowse, EXITkey_FSI, HELPkey_FSI);
PWt.hLines = headerBrowse;
PWt.tLines = trailerBrowse;
PWt.exitChars = exitCharsBrowse;
}
else {
EncodeKeyDefinitions (1, trailerEdit, ENTERkey_FSI, EXITkey_FSI,
HELPkey_FSI);
PWt.hLines = BOO(STRINGdataType(dataType),headerCHAR,headerNoCHAR);
PWt.tLines = trailerEdit;
PWt.exitChars = exitCharsEdit;
}
PWt.maxChars = BOO(STRINGdataType(dataType),
(int)(numElems+3),MAX_nonSTRING_VALUE_LEN);
nBytes = (size_t) (PWt.maxChars + 1);
PWt.value = (char *) cdf_AllocateMemory (nBytes, FatalError);
if (useFormat) {
status = GetFormatEntry (zVar, varN, &format);
if (!ReportStatus(status,FALSE)) return FALSE;
}
else
format = NULL;
EncodeValuesFormat (dataType, numElems, binary, PWt.value, format, 0, 0,
EPOCH0_STYLE);
cdf_FreeMemory (binary, FatalError);
if (format != NULL) cdf_FreeMemory (format, FatalError);
cursorAt = BOO(STRINGdataType(dataType),
strlen(PWt.value) - 1,strlen(PWt.value));
PromptWindow (NEWpw, &PWt, cursorAt, LogicalTRUE);
for (;;) {
if (EnterPW(&PWt,PADVALUEhelpID)) {
long nElemsEntered; void *newBinary;
if (DecodeValues(PWt.value,dataType,
&nElemsEntered,&newBinary,EPOCH0_STYLE)) {
if (nElemsEntered == numElems) {
status = CDFlib (PUT_, VAR_PADVALUE(zVar), newBinary,
NULL_);
if (ReportStatus(status,FALSE)) {
PromptWindow (DELETEpw, &PWt);
cdf_FreeMemory (newBinary, FatalError);
cdf_FreeMemory (PWt.value, FatalError);
*changed = TRUE;
return TRUE;
}
if (NoMoreAccess(NULL)) {
PromptWindow (DELETEpw, &PWt);
return FALSE;
}
cdf_FreeMemory (newBinary, FatalError);
}
else {
static char tooMany[] = "Illegal number of elements (too many).";
static char tooFew[] = "Illegal number of elements (too few).";
ProblemWindow (BOO(nElemsEntered > numElems,tooMany,tooFew), FALSE);
cdf_FreeMemory (newBinary, FatalError);
}
}
else
ProblemWindow ("Illegal value.", FALSE);
}
else {
PromptWindow (DELETEpw, &PWt);
cdf_FreeMemory (PWt.value, FatalError);
return TRUE;
}
}
}
syntax highlighted by Code2HTML, v. 0.9.1