/*--------------------------------------------------------------------------*/
int sci_x_choice(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrdefaultValuesAdr = NULL;
int* piAddrlabelsAdr = NULL;
int* piAddrlineLabelsAdr = NULL;
double* emptyMatrixAdr = NULL;
int nbRow = 0, nbCol = 0;
int nbRowDefaultValues = 0, nbColDefaultValues = 0;
int nbRowLineLabels = 0, nbColLineLabels = 0;
int messageBoxID = 0;
char **labelsAdr = NULL;
char **lineLabelsAdr = NULL;
double *defaultValues = NULL;
int *defaultValuesInt = NULL;
int userValueSize = 0;
int *userValue = NULL;
double *userValueDouble = NULL;
int K = 0;
CheckInputArgument(pvApiCtx, 3, 3);
CheckOutputArgument(pvApiCtx, 0, 1);
/* READ THE DEFAULT VALUES */
if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrdefaultValuesAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValues);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
defaultValuesInt = (int *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(int));
for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++)
{
defaultValuesInt[K] = (int)defaultValues[K];
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Real or complex vector expected.\n"), fname, 1);
return FALSE;
}
/* READ THE MESSAGE */
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlabelsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
FREE(defaultValuesInt);
return FALSE;
}
/* Create the Java Object */
messageBoxID = createMessageBox();
/* Title is a default title */
setMessageBoxTitle(messageBoxID, _("Scilab Choices Request"));
/* Message */
setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
/* READ THE LABELS */
if (checkInputArgumentType(pvApiCtx, 3, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlineLabelsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow != 1 && nbCol != 1)
{
freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
return FALSE;
}
setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3);
return FALSE;
}
/* Default selected buttons */
setMessageBoxDefaultSelectedButtons(messageBoxID, defaultValuesInt, nbRowDefaultValues * nbColDefaultValues);
/* Display it and wait for a user input */
messageBoxDisplayAndWait(messageBoxID);
/* Read the user answer */
userValueSize = getMessageBoxValueSize(messageBoxID);
if (userValueSize == 0)
{
nbRow = 0;
nbCol = 0;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
else
{
userValue = (int*)getMessageBoxUserSelectedButtons(messageBoxID);
userValueDouble = (double *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(double));
for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++)
{
userValueDouble[K] = userValue[K];
}
sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValueDouble);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
/* TO DO : do a delete [] getMessageBoxUserSelectedButtons */
}
FREE(defaultValuesInt);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return TRUE;
}
/*--------------------------------------------------------------------------*/
int sci_x_dialog(char *fname,unsigned long fname_len)
{
int nbRow = 0, nbCol = 0;
int messageBoxID = 0;
char **initialValueAdr = 0;
char **labelsAdr = 0;
int userValueSize = 0;
char **userValue = NULL;
int emptyMatrixAdr = 0;
CheckRhs(1,2);
CheckLhs(0,1);
if (VarType(1) == sci_strings)
{
GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &labelsAdr);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1);
return FALSE;
}
/* Create the Java Object */
messageBoxID = createMessageBox();
/* Title is a default title */
setMessageBoxTitle(messageBoxID, _("Scilab Input Value Request"));
/* Message */
setMessageBoxMultiLineMessage(messageBoxID, getStringMatrixFromStack((size_t)labelsAdr), nbCol*nbRow);
freeArrayOfString(labelsAdr, nbCol*nbRow);
if (Rhs == 2)
{
if (VarType(2) == sci_strings)
{
GetRhsVar(2,MATRIX_OF_STRING_DATATYPE,&nbRow,&nbCol,&initialValueAdr);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
return FALSE;
}
setMessageBoxInitialValue(messageBoxID, getStringMatrixFromStack((size_t)initialValueAdr), nbCol*nbRow);
freeArrayOfString(initialValueAdr, nbCol*nbRow);
}
/* Display it and wait for a user input */
messageBoxDisplayAndWait(messageBoxID);
/* Read the user answer */
userValueSize = getMessageBoxValueSize(messageBoxID);
if (userValueSize == 0)
{
nbRow = 0;nbCol = 0;
CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &emptyMatrixAdr);
}
else
{
userValue = getMessageBoxValue(messageBoxID);
nbCol = 1;
CreateVarFromPtr(Rhs+1, MATRIX_OF_STRING_DATATYPE, &userValueSize, &nbCol, userValue);
/* TO DO : delete of userValue */
}
LhsVar(1) = Rhs+1;
PutLhsVar();
return TRUE;
}
/*--------------------------------------------------------------------------*/
int sci_x_dialog(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrlabelsAdr = NULL;
int* piAddrinitialValueAdr = NULL;
double* emptyMatrixAdr = NULL;
int nbRow = 0, nbCol = 0;
int messageBoxID = 0;
char **initialValueAdr = 0;
char **labelsAdr = 0;
int userValueSize = 0;
char **userValue = NULL;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1);
return FALSE;
}
/* Create the Java Object */
messageBoxID = createMessageBox();
/* Title is a default title */
setMessageBoxTitle(messageBoxID, _("Scilab Input Value Request"));
/* Message */
setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
if (nbInputArgument(pvApiCtx) == 2)
{
if (VarType(2) == sci_strings)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrinitialValueAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrinitialValueAdr, &nbRow, &nbCol, &initialValueAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
return FALSE;
}
setMessageBoxInitialValue(messageBoxID, initialValueAdr, nbCol * nbRow);
freeAllocatedMatrixOfString(nbRow, nbCol, initialValueAdr);
}
/* Display it and wait for a user input */
messageBoxDisplayAndWait(messageBoxID);
/* Read the user answer */
userValueSize = getMessageBoxValueSize(messageBoxID);
if (userValueSize == 0)
{
nbRow = 0;
nbCol = 0;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
else
{
userValue = getMessageBoxValue(messageBoxID);
nbCol = 1;
CreateVarFromPtr(nbInputArgument(pvApiCtx) + 1, MATRIX_OF_STRING_DATATYPE, &userValueSize, &nbCol, userValue);
/* TO DO : delete of userValue */
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return TRUE;
}
/*--------------------------------------------------------------------------*/
int sci_x_mdialog(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrlabelsAdr = NULL;
int* piAddrlineLabelsAdr = NULL;
int* piAddrdefaultValuesAdr = NULL;
int* piAddrcolumnLabelsAdr = NULL;
double* emptyMatrixAdr = NULL;
int nbRow = 0, nbCol = 0;
int nbRowDefaultValues = 0, nbColDefaultValues = 0;
int nbRowLineLabels = 0, nbColLineLabels = 0;
int nbRowColumnLabels = 0, nbColColumnLabels = 0;
int messageBoxID = 0;
char **labelsAdr = NULL;
char **lineLabelsAdr = NULL;
char **columnLabelsAdr = NULL;
char **defaultValuesAdr = NULL;
int userValueSize = 0;
char **userValue = NULL;
CheckInputArgument(pvApiCtx, 3, 4);
CheckOutputArgument(pvApiCtx, 0, 1);
/* READ THE LABELS */
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1);
return FALSE;
}
/* Create the Java Object */
messageBoxID = createMessageBox();
/* Title is a default title */
setMessageBoxTitle(messageBoxID, _("Scilab Multiple Values Request"));
/* Message */
setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
/* READ THE LINE LABELS */
if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlineLabelsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
if (nbRowLineLabels != 1 && nbColLineLabels != 1)
{
freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 2);
return FALSE;
}
setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
return FALSE;
}
/* READ THE COLUMN LABELS or DEFAULT VALUES */
if (checkInputArgumentType(pvApiCtx, 3, sci_strings))
{
if (nbInputArgument(pvApiCtx) == 3)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrdefaultValuesAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
return 1;
}
if ((nbRowDefaultValues != nbRowLineLabels) || (nbColDefaultValues != nbColLineLabels))
{
freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: It must have same dimensions as argument #%d.\n"), fname, 3, 2);
return FALSE;
}
setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
}
else
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrcolumnLabelsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrcolumnLabelsAdr, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
return 1;
}
if (nbRowColumnLabels != 1 && nbColColumnLabels != 1)
{
freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
return FALSE;
}
setMessageBoxColumnLabels(messageBoxID, columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels);
freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr);
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3);
return FALSE;
}
if (nbInputArgument(pvApiCtx) == 4)
{
/* READ DEFAULT VALUES */
if (checkInputArgumentType(pvApiCtx, 4, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrdefaultValuesAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 4.
// DO NOT FORGET TO RELEASE MEMORY via freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr).
if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4);
return 1;
}
if ((nbRowDefaultValues != nbRowLineLabels * nbColLineLabels) || (nbColDefaultValues != nbRowColumnLabels * nbColColumnLabels))
{
Scierror(999, _("%s: Wrong size for input argument #%d: %d x %d matrix of strings expected.\n"), fname, 4, nbRowLineLabels * nbColLineLabels, nbRowColumnLabels * nbColColumnLabels);
freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
return FALSE;
}
setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 4);
return FALSE;
}
}
/* Display it and wait for a user input */
messageBoxDisplayAndWait(messageBoxID);
/* Read the user answer */
userValueSize = getMessageBoxValueSize(messageBoxID);
if (userValueSize == 0)
{
nbRow = 0;
nbCol = 0;
// YOU MUST REMOVE YOUR VARIABLE DECLARATION "int emptyMatrixAdr".
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
else
{
userValue = getMessageBoxValue(messageBoxID);
nbCol = 1;
nbRowDefaultValues = nbColLineLabels * nbRowLineLabels;
nbColDefaultValues = 1;
if (nbInputArgument(pvApiCtx) == 4)
{
nbColDefaultValues = nbColColumnLabels * nbRowColumnLabels;
}
createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValue);
delete[] userValue;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return TRUE;
}
