/*--------------------------------------------------------------------------*/
int sci_scitlist(char *fname, unsigned long fname_len)
{
if (Rhs >= 1)
{
#define RLIST_FIELDNAME "r"
SciErr sciErr;
int *piAddressVarOne = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne))
{
int m = 0;
int n = 0;
char **pStrs = NULL;
BOOL bIsRfield = FALSE;
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarOne, &m, &n, &pStrs) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
bIsRfield = (BOOL)(strcmp(pStrs[0], RLIST_FIELDNAME) == 0);
freeAllocatedMatrixOfString(m, n, pStrs);
pStrs = NULL;
// it is not allowed to create a tlist of type 'r'
// 'r' type reserved to rlist
if (bIsRfield)
{
Scierror(999, _("%s: Can not create a tlist with input argument #%d.\n"), fname, 1);
return 0;
}
}
}
C2F(scilist)(fname, fname_len);
return 0;
}
/**
* Read a vector of string on the stack.
*
* @param _pvCtx private api context (opaque structure)
* @param rhsPosition the position on the stack.
* @param[out] out the read value.
* @param[out] vectorLength the length of the vector.
* @param fname the function name used for the call.
* @return status of the operation (<> 0 on error)
*/
int readVectorString(void* _pvCtx, int rhsPosition, char*** out, int* vectorLength, char* fname)
{
int* argumentPointer = NULL;
int rowsArgument = 0;
int colsArgument = 0;
SciErr sciErr;
sciErr = getVarAddressFromPosition(_pvCtx, rhsPosition, &argumentPointer);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, rhsPosition);
return -1;
}
if (getAllocatedMatrixOfString(_pvCtx, argumentPointer, &rowsArgument, &colsArgument, out))
{
return -1;
}
*vectorLength = rowsArgument * colsArgument;
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_xstringb(char *fname, void *pvApiCtx)
{
SciErr sciErr;
int* piAddrl1 = NULL;
double* l1 = NULL;
int* piAddrl2 = NULL;
double* l2 = NULL;
int* piAddrStr = NULL;
int* piAddrl4 = NULL;
double* l4 = NULL;
int* piAddrl5 = NULL;
double* l5 = NULL;
int* piAddrl6 = NULL;
char* l6 = NULL;
int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, m5 = 0, n5 = 0, m6 = 0, n6 = 0;
BOOL autoSize = TRUE ;
double x = 0., y = 0., w = 0., hx = 0.;
char **Str = NULL;
double rect[4], angle = 0.;
long hdlstr = 0;
double userSize[2] ;
int textBoxMode = 1; // 0 : off | 1 : centered | 2 : filled
if ( nbInputArgument(pvApiCtx) <= 0 )
{
/* demo */
sci_demo(fname, pvApiCtx);
return 0 ;
}
CheckInputArgument(pvApiCtx, 5, 6);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
//CheckScalar
if (m1 != 1 || n1 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 1);
return 1;
}
x = *l1;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 2.
// YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l2".
sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
return 1;
}
//CheckScalar
if (m2 != 1 || n2 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2);
return 1;
}
y = *l2;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrStr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m3, &n3, &Str))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
return 1;
}
if ( m3*n3 == 0 )
{
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrl4);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 4.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrl4, &m4, &n4, &l4);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
return 1;
}
//CheckScalar
if (m4 != 1 || n4 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4);
return 1;
}
w = *l4;
sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrl5);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 5.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrl5, &m5, &n5, &l5);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 5);
return 1;
}
//CheckScalar
if (m5 != 1 || n5 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 5);
return 1;
}
hx = *l5;
if (nbInputArgument(pvApiCtx) == 6)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddrl6);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a string at position 6.
if (isScalar(pvApiCtx, piAddrl6) == 0)
{
Scierror(999, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 6);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddrl6, &l6))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 6);
return 1;
}
if (strcmp(l6, "fill") == 0 )
{
autoSize = FALSE ;
textBoxMode = 2;
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 6, "fill");
return 0;
}
freeAllocatedSingleString(l6);
}
userSize[0] = w ;
userSize[1] = hx ;
Objstring (Str, m3, n3, x, y, &angle, rect, autoSize, userSize, &hdlstr, textBoxMode, NULL, NULL, FALSE, TRUE, FALSE, ALIGN_CENTER);
freeArrayOfString(Str, m3 * n3);
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
/*--------------------------------------------------------------------------
* sciset(choice-name,x1,x2,x3,x4,x5)
* or xset()
*-----------------------------------------------------------*/
int sci_set(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddr1 = NULL;
int* piAddr2 = NULL;
int* piAddr3 = NULL;
int lw = 0;
int isMatrixOfString = 0;
char* pstProperty = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
if (sciErr.iErr)
{
//error
return 1;
}
if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1))
{
OverLoad(1);
return 0;
}
CheckRhs(2, 3);
CheckLhs(0, 1);
if (isDoubleType(pvApiCtx, piAddr1)) /* tclsci handle */
{
/* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */
OverLoad(1);
return 0;
}
else /* others types */
{
int iRows1 = 0, iCols1 = 0;
int iRows2 = 0, iCols2 = 0;
int iRows3 = 0, iCols3 = 0;
void* _pvData = NULL;
unsigned long hdl;
char *pobjUID = NULL;
int iType1 = 0;
int valueType = 0; /* type of the rhs */
int setStatus = 0;
/* after the call to sciSet get the status : 0 <=> OK, */
/* -1 <=> Error, */
/* 1 <=> nothing done */
/* set or create a graphic window */
sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
if (sciErr.iErr)
{
//error
return 1;
}
switch (iType1)
{
case sci_handles:
/* first is a scalar argument so it's a gset(hdl,"command",[param]) */
/* F.Leray; INFO: case 9 is considered for a matrix of graphic handles */
CheckRhs(3, 3);
if (isScalar(pvApiCtx, piAddr1) == FALSE)
{
OverLoad(1);
return 0;
}
getScalarHandle(pvApiCtx, piAddr1, (long long*)&hdl);
pobjUID = (char*)getObjectFromHandle(hdl);
getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
getAllocatedSingleString(pvApiCtx, piAddr2, &pstProperty);
valueType = getInputArgumentType(pvApiCtx, 3);
getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
if ((strcmp(pstProperty, "user_data") == 0) || (stricmp(pstProperty, "userdata") == 0))
{
/* in this case set_user_data_property
* directly uses the third position in the stack
* to get the variable which is to be set in
* the user_data property (any data type is allowed) S. Steer */
_pvData = (void*)piAddr3; /*position in the stack */
iRows3 = -1; /*unused */
iCols3 = -1; /*unused */
valueType = -1;
}
else if (valueType == sci_matrix)
{
getMatrixOfDouble(pvApiCtx, piAddr3, &iRows3, &iCols3, (double**)&_pvData);
}
else if (valueType == sci_boolean)
{
getMatrixOfBoolean(pvApiCtx, piAddr3, &iRows3, &iCols3, (int**)&_pvData);
}
else if (valueType == sci_handles)
{
getMatrixOfHandle(pvApiCtx, piAddr3, &iRows3, &iCols3, (long long**)&_pvData);
}
else if (valueType == sci_strings)
{
if ( strcmp(pstProperty, "tics_labels") != 0 && strcmp(pstProperty, "auto_ticks") != 0 &&
strcmp(pstProperty, "axes_visible") != 0 && strcmp(pstProperty, "axes_reverse") != 0 &&
strcmp(pstProperty, "text") != 0 && stricmp(pstProperty, "string") != 0 &&
stricmp(pstProperty, "tooltipstring") != 0) /* Added for uicontrols */
{
getAllocatedSingleString(pvApiCtx, piAddr3, (char**)&_pvData);
iRows3 = (int)strlen((char*)_pvData);
iCols3 = 1;
}
else
{
isMatrixOfString = 1;
getAllocatedMatrixOfString(pvApiCtx, piAddr3, &iRows3, &iCols3, (char***)&_pvData);
}
}
else if (valueType == sci_list) /* Added for callbacks */
{
iCols3 = 1;
getListItemNumber(pvApiCtx, piAddr3, &iRows3);
_pvData = (void*)piAddr3; /* In this case l3 is the list position in stack */
}
break;
case sci_strings: /* first is a string argument so it's a set("command",[param]) */
CheckRhs(2, 2);
getAllocatedSingleString(pvApiCtx, piAddr1, &pstProperty);
hdl = 0;
pobjUID = NULL;
valueType = getInputArgumentType(pvApiCtx, 2);
getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
if (valueType == sci_matrix)
{
getMatrixOfDouble(pvApiCtx, piAddr2, &iRows3, &iCols3, (double**)&_pvData);
}
else if (valueType == sci_handles)
{
getMatrixOfHandle(pvApiCtx, piAddr2, &iRows3, &iCols3, (long long**)&_pvData);
}
else if (valueType == sci_strings)
{
if (strcmp(pstProperty, "tics_labels") == 0 || strcmp(pstProperty, "auto_ticks") == 0 ||
strcmp(pstProperty, "axes_visible") == 0 || strcmp(pstProperty, "axes_reverse") == 0 ||
strcmp(pstProperty, "text") == 0)
{
isMatrixOfString = 1;
getAllocatedMatrixOfString(pvApiCtx, piAddr2, &iRows3, &iCols3, (char***)&_pvData);
}
else
{
getAllocatedSingleString(pvApiCtx, piAddr2, (char**)&_pvData);
iRows3 = (int)strlen((char*)_pvData);
iCols3 = 1;
}
}
break;
default:
Scierror(999, _("%s: Wrong type for input argument #%d: String or handle expected.\n"), fname, 1);
return 0;
break;
}
if (hdl != 0)
{
pobjUID = (char*)getObjectFromHandle(hdl);
if (pobjUID == NULL)
{
Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
return 0;
}
// Only set the property whitout doing anythig else.
//static int sciSet(void* _pvCtx, char *pobjUID, char *marker, void* value, int valueType, int *numrow, int *numcol)
setStatus = callSetProperty(pvApiCtx, pobjUID, _pvData, valueType, iRows3, iCols3, pstProperty);
if (valueType == sci_strings)
{
//free allacted data
if (isMatrixOfString == 1)
{
freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData);
}
else
{
freeAllocatedSingleString((char*)_pvData);
}
}
}
else
{
#define NB_PROPERTIES_SUPPORTED 7
/* No object specified */
/* ONLY supported properties are */
/* 'current_entity' */
/* 'hdl' */
/* 'current_figure' */
/* 'current_axes' */
/* 'default_values' */
/* 'figure_style' for compatibility but do nothing */
/* others values must return a error */
char *propertiesSupported[NB_PROPERTIES_SUPPORTED] = { "current_entity",
"hdl",
"current_figure",
"current_axes",
"figure_style",
"default_values",
"auto_clear"
};
int i = 0;
int iPropertyFound = 0;
for (i = 0; i < NB_PROPERTIES_SUPPORTED; i++)
{
if (strcmp(propertiesSupported[i], pstProperty) == 0)
{
iPropertyFound = 1;
}
}
if (iPropertyFound)
{
// we do nothing with "figure_style" "new" (to remove in 5.4)
int bDoSet = ((isMatrixOfString) && (strcmp(pstProperty, "figure_style") == 0) && (strcmp(((char**)_pvData)[0], "new") == 0)) != 1;
if (bDoSet)
{
setStatus = callSetProperty(pvApiCtx, NULL, _pvData, valueType, iRows3, iCols3, pstProperty);
if (valueType == sci_strings)
{
//free allocated data
if (isMatrixOfString == 1)
{
freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData);
}
else
{
freeAllocatedSingleString((char*)_pvData);
}
}
}
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: a valid property expected.\n"), fname, 1);
if (isMatrixOfString)
{
freeArrayOfString((char **)_pvData, iRows3 * iCols3);
}
return 0;
}
}
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int xs2file(char * fname, ExportFileType fileType )
{
SciErr sciErr;
int* piAddrl1 = NULL;
int* piAddrfileName = NULL;
int* piAddrsciOrientation = NULL;
int* piAddrquality = NULL;
double* quality = NULL;
/* Check input and output sizes */
CheckOutputArgument(pvApiCtx, 0, 1);
if (isVectorialExport(fileType) || fileType == JPG_EXPORT)
{
CheckInputArgument(pvApiCtx, 2, 3);
}
else
{
CheckInputArgument(pvApiCtx, 2, 2);
}
if ((!checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: An integer or a handle expected.\n"), fname, 1);
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 1;
}
if ( (checkInputArgumentType(pvApiCtx, 2, sci_strings)) )
{
char **fileName = NULL;
char *real_filename = NULL;
float jpegCompressionQuality = 0.95f;
ExportOrientation orientation = EXPORT_PORTRAIT; /* default orientation */
int m1 = 0, n1 = 0;
int figurenum = -1;
char* figureUID = NULL;
char *status = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
/* get handle by figure number */
if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
{
// Retrieve a matrix of double at position 1.
int* l1 = NULL;
sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrl1, &m1, &n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
return 1;
}
if (m1 * n1 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1);
return 1;
}
figurenum = *l1;
if (!sciIsExistingFigure(figurenum))
{
Scierror(999, "%s: Input argument #%d must be a valid figure_id.\n", fname, 1);
return 1;
}
figureUID = (char*)getFigureFromIndex(figurenum);
}
/* check given handle */
else if (checkInputArgumentType(pvApiCtx, 1, sci_handles))
{
int iHandleType = -1;
int* piHandleType = &iHandleType;
long long* l1 = NULL;
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
return 1;
}
if (m1 * n1 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return 1;
}
figureUID = (char*)getObjectFromHandle((unsigned long) * l1);
if (figureUID == NULL)
{
Scierror(999, _("%s: Input argument #%d must be a valid handle.\n"), fname, 1);
return 1;
}
getGraphicObjectProperty(figureUID, __GO_TYPE__, jni_int, (void**)&piHandleType);
if (iHandleType != __GO_FIGURE__)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A ''%s'' handle expected.\n"), fname, 1, "Figure");
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar or figure handle expected.\n"), fname, 1);
return 1;
}
/* get file name */
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrfileName);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrfileName, &m1, &n1, &fileName))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
if (m1 * n1 == 1)
{
if (nbInputArgument(pvApiCtx) == 3)
{
int nbCol = 0;
int nbRow = 0;
if (isVectorialExport(fileType))
{
char **sciOrientation = NULL;
if ((!checkInputArgumentType(pvApiCtx, 3, sci_strings)))
{
freeAllocatedMatrixOfString(m1, n1, fileName);
Scierror(999, _("%s: Wrong type for input argument #%d: Single character string expected.\n"), fname, 3);
return 1;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrsciOrientation);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrsciOrientation, &nbRow, &nbCol, &sciOrientation))
{
freeAllocatedMatrixOfString(m1, n1, fileName);
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow * nbCol == 1)
{
/* Value should be 'landscape' or 'portrait' but check only the first character */
/* for compatibility with Scilab 4*/
if (strcmp(sciOrientation[0], "landscape") == 0 || strcmp(sciOrientation[0], "l") == 0)
{
freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation);
orientation = EXPORT_LANDSCAPE;
}
else if (strcmp(sciOrientation[0], "portrait") == 0 || strcmp(sciOrientation[0], "p") == 0)
{
freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation);
orientation = EXPORT_PORTRAIT;
}
else
{
freeAllocatedMatrixOfString(m1, n1, fileName);
freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 3, "portrait", "landscape");
return 1;
}
}
else
{
freeAllocatedMatrixOfString(m1, n1, fileName);
freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation);
Scierror(999, _("%s: Wrong size for input argument #%d: Single character string expected.\n"), fname, 3);
return 1;
}
}
else
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrquality);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 3.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrquality, &nbRow, &nbCol, &quality);
if (sciErr.iErr)
{
freeAllocatedMatrixOfString(m1, n1, fileName);
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
return 1;
}
if (nbRow != 1 || nbCol != 1 || *quality < 0 || *quality > 1)
{
freeAllocatedMatrixOfString(m1, n1, fileName);
Scierror(999, _("%s: Wrong type for input argument #%d: A real between 0 and 1 expected.\n"), fname, 3);
return 1;
}
jpegCompressionQuality = (float) * quality;
}
}
/* Replaces SCI, ~, HOME, TMPDIR by the real path */
real_filename = expandPathVariable(fileName[0]);
/* Call the function for exporting file */
status = exportToFile(figureUID, real_filename, fileType, jpegCompressionQuality, orientation);
/* free pointers no more used */
if (real_filename)
{
FREE(real_filename);
real_filename = NULL;
}
freeAllocatedMatrixOfString(m1, n1, fileName);
/* treat errors */
if (strlen(status) != 0)
{
Scierror(999, _("%s: %s\n"), fname, status);
return 1;
}
}
else
{
freeAllocatedMatrixOfString(m1, n1, fileName);
Scierror(999, _("%s: Wrong size for input argument #%d: Single character string expected.\n"), fname, 2);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Single character string expected.\n"), fname, 2);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
int stringExample(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddr = NULL;
int iType = 0;
int iRet = 0;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (isStringType(pvApiCtx, piAddr))
{
if (isScalar(pvApiCtx, piAddr))
{
char* pstData = NULL;
iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
if (iRet)
{
freeAllocatedSingleString(pstData);
return iRet;
}
iRet = createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstData);
if (iRet)
{
freeAllocatedSingleString(pstData);
return iRet;
}
freeAllocatedSingleString(pstData);
}
else
{
int iRows = 0;
int iCols = 0;
char** pstData = NULL;
iRet = getAllocatedMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &pstData);
if (iRet)
{
freeAllocatedMatrixOfString(iRows, iCols, pstData);
return iRet;
}
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pstData);
if (sciErr.iErr)
{
freeAllocatedMatrixOfString(iRows, iCols, pstData);
printError(&sciErr, 0);
return sciErr.iErr;
}
freeAllocatedMatrixOfString(iRows, iCols, pstData);
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
AssignOutputVariable(pvApiCtx, 1) = 0;
}
return 0;
}
int ScilabGateway::deff(char * fname, const int envId, void * pvApiCtx)
{
static int ONE = 1;
static int TWO = 2;
static int THREE = 3;
SciErr err;
char ** names[] = {0, 0, 0};
int ret = 0;
std::ostringstream os;
char * str;
int * addr[] = {0, 0, 0};
int rows[] = {0, 0, 0};
int cols[] = {0, 0, 0};
int error = 0;
char * cwd = 0;
CheckInputArgument(pvApiCtx, 3, 3);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper & helper = env.getOptionsHelper();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
for (int i = 0; i < 3; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i + 1, &(addr[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr[i]))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), 1);
}
err = getVarDimension(pvApiCtx, addr[i], &(rows[i]), &(cols[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
if (rows[0] != 1 || cols[0] != 1)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions for input argument #%d: A single string expected."), 1);
}
if (rows[1] != rows[2] || cols[1] != cols[2])
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions: arguments #2 and #3 must have the same."));
}
for (int i = 0; i < 3; i++)
{
if (getAllocatedMatrixOfString(pvApiCtx, addr[i], &(rows[i]), &(cols[i]), &(names[i])))
{
for (int j = 0; j < i; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
cwd = scigetcwd(&error);
if (error)
{
FREE(cwd);
cwd = 0;
}
try
{
ret = env.loadclass(names[0][0], cwd, false, helper.getAllowReload());
}
catch (std::exception & e)
{
FREE(cwd);
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw;
}
FREE(cwd);
for (int i = 0; i < rows[1] * cols[1]; i++)
{
err = createMatrixOfString(pvApiCtx, ONE, 1, 1, (const char * const *) & (names[2][i]));
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
os.str("");
os << "y=" << names[2][i] << "(varargin)" << std::flush;
str = strdup(os.str().c_str());
err = createMatrixOfString(pvApiCtx, TWO, 1, 1, (const char * const *)&str);
free(str);
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
os.str("");
os << "y=invoke_lu(int32(" << ret << "),int32(" << envId << "),\"" << names[1][i] << "\",varargin)" << std::flush;
str = strdup(os.str().c_str());
err = createMatrixOfString(pvApiCtx, THREE, 1, 1, (const char * const *)&str);
free(str);
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
SciString(&ONE, const_cast<char *>("!_deff_wrapper"), &ONE, &THREE);
}
for (int i = 0; i < 3; i++)
{
freeAllocatedMatrixOfString(rows[0], cols[0], names[i]);
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_helpbrowser(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrhelpAdr = NULL;
int* piAddrkeywordAdr = NULL;
int* piAddrfullTextAdr = NULL;
int* fullTextAdr = NULL;
int nbRow = 0;
int nbCol = 0;
char** keywordAdr = NULL;
int nbRowHelp = 0;
int nbColHelp = 0;
char** helpAdr = NULL;
char** languageAdr = NULL;
int ret = 1;
CheckInputArgument(pvApiCtx, 2, 4);
CheckOutputArgument(pvApiCtx, 0, 1);
/* We load SciNotes when calling javahelp because we have no way to know
* to load it when using Javahelp because it can call SciNotes directly */
if (!loadedDep)
{
loadOnUseClassPath("SciNotes");
loadedDep = TRUE;
}
if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhelpAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrhelpAdr, &nbRowHelp, &nbColHelp, &helpAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
return 1;
}
}
else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
{
helpAdr = NULL; /* No toolboxes installed */
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
return FALSE;
}
if (nbInputArgument(pvApiCtx) == 2)
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
int* piAddrlanguageAdr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlanguageAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
ret = launchHelpBrowser(helpAdr, nbRowHelp * nbColHelp, languageAdr[0]);
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
}
else if (nbInputArgument(pvApiCtx) == 4)
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrkeywordAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrkeywordAdr, &nbRow, &nbCol, &keywordAdr))
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedMatrixOfString(nbRow, nbCol, keywordAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
{
int* piAddrlanguageAdr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlanguageAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
return FALSE;
}
if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrfullTextAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 4.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddrfullTextAdr, &nbRow, &nbCol, &fullTextAdr);
if (sciErr.iErr)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 4);
return 1;
}
if (nbRow*nbCol != 1)
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
}
else
{
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
ret = searchKeyword(helpAdr, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *fullTextAdr == 1);
if (helpAdr)
{
freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
}
freeAllocatedSingleString(*keywordAdr);
freeAllocatedSingleString(*languageAdr);
}
else
{
Scierror(999, _("%s: Wrong number of input arguments: %d or %d expected.\n"), fname, 2, 4);
return FALSE;
}
if (ret == 0)
{
return FALSE;
}
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return TRUE;
}
/*--------------------------------------------------------------------------*/
int sci_xtitle(char * fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddr4 = NULL;
int* boxPtr = NULL;
int* piAddrStr = NULL;
int narg = 0;
int nbLabels = 0; /* number of modified labels */
int box = 0;
BOOL isBoxSpecified = FALSE;
int iSubwinUID = 0;
static rhs_opts opts[] =
{
{ -1, "boxed", -1, 0, 0, NULL},
{ -1, NULL, -1, 0, 0, NULL}
};
if (nbInputArgument(pvApiCtx) <= 0)
{
sci_demo(fname, fname_len);
return 0;
}
CheckInputArgument(pvApiCtx, 1, 5);
nbLabels = nbInputArgument(pvApiCtx);
/* get the given options from the name in opts */
if (!getOptionals(pvApiCtx, fname, opts))
{
/* error */
return 0;
}
/* compatibility with previous version in which box was put */
/* at the fourth position */
if (nbInputArgument(pvApiCtx) == 4)
{
int type = getInputArgumentType(pvApiCtx, 4);
if (type == 1 || type == 8)/* double or int */
{
int n = 0, m = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 4.
sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr4, &m, &n, &boxPtr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
return 1;
}
//CheckScalar
if (m != 1 || n != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4);
return 1;
}
box = *boxPtr;
nbLabels--; /* it is not a label text */
isBoxSpecified = TRUE;
}
}
if (opts[0].iPos != -1 && !isBoxSpecified)
{
/* check if "box" is in the options */
getScalarBoolean(pvApiCtx, opts[0].piAddr, &box);
if (opts[0].iRows != 1 || opts[0].iCols != 1)
{
/* check size */
Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
return 1;
}
nbLabels--; /* it is not a label text */
}
iSubwinUID = getOrCreateDefaultSubwin();
for (narg = 1 ; narg <= nbLabels ; narg++)
{
int m = 0, n = 0;
char **Str = NULL;
int iModifiedLabel = 0;
int* piModifiedLabel = &iModifiedLabel;
sciErr = getVarAddressFromPosition(pvApiCtx, narg, &piAddrStr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position narg.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m, &n, &Str))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, narg);
return 1;
}
if (m * n == 0)
{
continue;
}
switch (narg)
{
case 1:
getGraphicObjectProperty(iSubwinUID, __GO_TITLE__, jni_int, (void **)&piModifiedLabel);
break;
case 2:
getGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel);
break;
case 3:
getGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel);
break;
case 4:
getGraphicObjectProperty(iSubwinUID, __GO_Z_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel);
break;
default:
break;
}
#if 0
startFigureDataWriting(pFigure);
#endif
sciSetText(iModifiedLabel, Str, m, n);
setGraphicObjectProperty(iModifiedLabel, __GO_FILL_MODE__, &box, jni_bool, 1);
#if 0
endFigureDataWriting(pFigure);
#endif
freeArrayOfString(Str, m * n);
}
setCurrentObject(iSubwinUID);
#if 0
sciDrawObj(pFigure);
#endif
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_messagebox(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrmessageAdr = NULL;
int* piAddrtitleAdr = NULL;
int* piAddriconAdr = NULL;
int* piAddrbuttonsTextAdr = NULL;
int* piAddrmodalOptionAdr = NULL;
double* buttonNumberAdr = NULL;
int messageBoxID = 0;
/* Used to read input arguments */
int nbRow = 0, nbCol = 0;
int nbRowButtons = 0, nbColButtons = 0;
int nbRowMessage = 0, nbColMessage = 0;
char **buttonsTextAdr = 0;
char **messageAdr = 0;
char **titleAdr = 0;
char **modalOptionAdr = 0;
char **iconAdr = 0;
/* Used to write output argument */
int buttonNumber = 0;
CheckInputArgument(pvApiCtx, 1, 5);
CheckOutputArgument(pvApiCtx, 0, 1);
/* Message to be displayed */
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
{
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: string expected.\n"), fname, 1);
return FALSE;
}
/* Title to be displayed */
if (nbInputArgument(pvApiCtx) >= 2)
{
if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrtitleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrtitleAdr, &nbRow, &nbCol, &titleAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 2);
return FALSE;
}
/* The title argument can be used to give the modal option */
if (isModalOption(titleAdr[0]))
{
modalOptionAdr = titleAdr;
titleAdr = NULL;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
return FALSE;
}
}
/* Icon to be displayed */
if (nbInputArgument(pvApiCtx) >= 3)
{
if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddriconAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddriconAdr, &nbRow, &nbCol, &iconAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
return 1;
}
if (nbRow * nbCol == 1)
{
/* The icon argument can be used to give the modal option or the buttons names */
if (isModalOption(iconAdr[0]))
{
modalOptionAdr = (char **)iconAdr;
iconAdr = NULL;
}
else if (!isIconName(iconAdr[0]))
{
buttonsTextAdr = (char **)iconAdr;
nbRowButtons = nbRow;
nbColButtons = nbCol;
iconAdr = NULL;
}
}
else /* More than one string --> buttons names */
{
buttonsTextAdr = (char **)iconAdr;
nbRowButtons = nbRow;
nbColButtons = nbCol;
iconAdr = NULL;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string or string vector expected.\n"), fname, 3);
return FALSE;
}
}
/* Buttons names */
if (nbInputArgument(pvApiCtx) >= 4)
{
if ((checkInputArgumentType(pvApiCtx, 4, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrbuttonsTextAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 4.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonsTextAdr, &nbRowButtons, &nbColButtons, &buttonsTextAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4);
return 1;
}
if (nbRow * nbCol == 1)
{
/* The buttons names argument can be used to give the modal option */
if (isModalOption(buttonsTextAdr[0]))
{
modalOptionAdr = buttonsTextAdr;
buttonsTextAdr = NULL;
}
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string or string vector expected.\n"), fname, 3);
return FALSE;
}
}
/* Modal option */
if (nbInputArgument(pvApiCtx) == 5)
{
if ((checkInputArgumentType(pvApiCtx, 5, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrmodalOptionAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 5.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrmodalOptionAdr, &nbRow, &nbCol, &modalOptionAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 5);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 5);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 5);
return FALSE;
}
}
/* Create the Java Object */
messageBoxID = createMessageBox();
/* Message */
setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbColMessage * nbRowMessage);
freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
/* Title */
if (titleAdr != NULL)
{
setMessageBoxTitle(messageBoxID, titleAdr[0]);
freeAllocatedMatrixOfString(nbRow, nbCol, titleAdr);
}
else
{
setMessageBoxTitle(messageBoxID, _("Scilab Message"));
}
/* Icon */
if (iconAdr != NULL)
{
setMessageBoxIcon(messageBoxID, iconAdr[0]);
freeAllocatedMatrixOfString(nbRow, nbCol, iconAdr);
}
/* Buttons */
if (buttonsTextAdr != NULL)
{
setMessageBoxButtonsLabels(messageBoxID, buttonsTextAdr, nbColButtons * nbRowButtons);
freeAllocatedMatrixOfString(nbRowButtons, nbColButtons, buttonsTextAdr);
}
/* Modal ? */
if (modalOptionAdr != NULL)
{
setMessageBoxModal(messageBoxID, !stricmp(modalOptionAdr[0], "modal"));
freeAllocatedMatrixOfString(nbRow, nbCol, modalOptionAdr);
}
else
{
setMessageBoxModal(messageBoxID, FALSE);
}
/* Display it and wait for a user input */
messageBoxDisplayAndWait(messageBoxID);
/* Return the index of the button selected */
if (nbOutputArgument(pvApiCtx) == 1)
{
/* Read the user answer */
buttonNumber = getMessageBoxSelectedButton(messageBoxID);
nbRow = 1;
nbCol = 1;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &buttonNumberAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
buttonNumberAdr[0] = buttonNumber;
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
AssignOutputVariable(pvApiCtx, 1) = 0;
}
ReturnArguments(pvApiCtx);
return TRUE;
}
/*--------------------------------------------------------------------------
* sciset(choice-name,x1,x2,x3,x4,x5)
* or xset()
*-----------------------------------------------------------*/
int sci_set(char *fname, void *pvApiCtx)
{
SciErr sciErr;
int i = 0;
int* piAddr1 = NULL;
int isMatrixOfString = 0;
char* pstNewProperty = NULL;
unsigned long hdl;
int iObjUID = 0;
int iType = 0;
int* piType = &iType;
int iSetProperty = 0;
int iRhs = nbInputArgument(pvApiCtx);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 1;
}
if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1))
{
OverLoad(1);
return 0;
}
CheckInputArgumentAtLeast(pvApiCtx, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
if (isDoubleType(pvApiCtx, piAddr1)) /* tclsci handle */
{
/* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */
OverLoad(1);
return 0;
}
if (iRhs == 2)
{
#define NB_PROPERTIES_SUPPORTED 7
/* No object specified */
/* ONLY supported properties are */
/* 'current_entity' */
/* 'hdl' */
/* 'current_figure' */
/* 'current_axes' */
/* 'default_values' */
/* 'figure_style' for compatibility but do nothing */
/* others values must return a error */
char *propertiesSupported[NB_PROPERTIES_SUPPORTED] =
{
"current_entity",
"hdl",
"current_figure",
"current_axes",
"figure_style",
"default_values",
"auto_clear"
};
int iPropertyFound = 0;
int* piAddr2 = NULL;
int iType2 = 0;
int iRows2 = 0;
int iCols2 = 0;
void* pvData = NULL;
char* pstProperty = NULL;
if (isStringType(pvApiCtx, piAddr1) == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddr1, &pstProperty))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 1);
return 1;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
if (sciErr.iErr)
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 1;
}
sciErr = getVarType(pvApiCtx, piAddr2, &iType2);
if (sciErr.iErr)
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 1;
}
switch (iType2)
{
case sci_matrix:
sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows2, &iCols2, (double**)&pvData);
if (sciErr.iErr)
{
freeAllocatedSingleString(pstProperty);
printError(&sciErr, 0);
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix expected.\n"), fname, 2);
return sciErr.iErr;
}
break;
case sci_handles :
sciErr = getMatrixOfHandle(pvApiCtx, piAddr2, &iRows2, &iCols2, (long long**)&pvData);
if (sciErr.iErr)
{
freeAllocatedSingleString(pstProperty);
printError(&sciErr, 0);
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of handle expected.\n"), fname, 3);
return 1;
}
break;
case sci_strings :
if (strcmp(pstProperty, "tics_labels") == 0 || strcmp(pstProperty, "auto_ticks") == 0 ||
strcmp(pstProperty, "axes_visible") == 0 || strcmp(pstProperty, "axes_reverse") == 0 ||
strcmp(pstProperty, "text") == 0 || strcmp(pstProperty, "ticks_format") == 0)
{
isMatrixOfString = 1;
if (getAllocatedMatrixOfString(pvApiCtx, piAddr2, &iRows2, &iCols2, (char***)&pvData))
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Wrong size for input argument #%d: A matrix of string expected.\n"), fname, 2);
return 1;
}
}
else
{
if (getAllocatedSingleString(pvApiCtx, piAddr2, (char**)&pvData))
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 2);
return 1;
}
iRows2 = (int)strlen((char*)pvData);
iCols2 = 1;
isMatrixOfString = 0;
}
break;
}
for (i = 0; i < NB_PROPERTIES_SUPPORTED; i++)
{
if (strcmp(propertiesSupported[i], pstProperty) == 0)
{
iPropertyFound = 1;
}
}
if (iPropertyFound)
{
callSetProperty(pvApiCtx, 0, pvData, iType2, iRows2, iCols2, pstProperty);
if (iType2 == sci_strings)
{
//free allocated data
if (isMatrixOfString == 1)
{
freeAllocatedMatrixOfString(iRows2, iCols2, (char**)pvData);
}
else
{
freeAllocatedSingleString((char*)pvData);
}
}
}
else
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Wrong value for input argument #%d: a valid property expected.\n"), fname, 1);
if (iType2 == sci_strings)
{
if (isMatrixOfString == 1)
{
freeAllocatedMatrixOfString(iRows2, iCols2, (char**)pvData);
}
else
{
freeAllocatedSingleString((char*)pvData);
}
}
return 0;
}
freeAllocatedSingleString(pstProperty);
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
if (iRhs % 2 != 1)
{
Scierror(999, _("%s: Wrong number of input argument(s) : an odd number is expected.\n"), fname);
return 0;
}
/* after the call to sciSet get the status : 0 <=> OK, */
/* -1 <=> Error, */
/* 1 <=> nothing done */
/* set or create a graphic window */
if (isHandleType(pvApiCtx, piAddr1) == 0 && isStringType(pvApiCtx, piAddr1) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A handle or a string expected.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddr1))
{
char* pstPath = NULL;
if (getAllocatedSingleString(pvApiCtx, piAddr1, &pstPath))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 1);
return 1;
}
iObjUID = search_path(pstPath);
if (iObjUID == 0)
{
Scierror(999, _("%s: Unable to find handle for path %s.\n"), fname, pstPath);
freeAllocatedSingleString(pstPath);
return 1;
}
}
else
{
//matrix of handle are managed by a %h_set
if (isScalar(pvApiCtx, piAddr1) == FALSE)
{
OverLoad(1);
return 0;
}
if (getScalarHandle(pvApiCtx, piAddr1, (long long*)&hdl))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single handle expected.\n"), fname, 1);
return 1;
}
iObjUID = getObjectFromHandle(hdl);
}
if (iObjUID == 0)
{
Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
return 0;
}
for (i = 1 ; i < iRhs ; i = i + 2)
{
int setStatus = 0;
int* piAddr2 = NULL;
int* piAddr3 = NULL;
int iPos = i + 1;
int isData = 0;
int iRows3 = 0;
int iCols3 = 0;
int iType3 = 0;
void* pvData = NULL;
char* pstProperty = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, iPos, &piAddr2);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos);
return 1;
}
if (isStringType(pvApiCtx, piAddr2) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, iPos);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddr2, &pstProperty))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, iPos);
return 1;
}
sciErr = getVarAddressFromPosition(pvApiCtx, iPos + 1, &piAddr3);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1);
return 1;
}
if ((pstProperty[0] == 'd' || pstProperty[0] == 'D') && stricmp("data", pstProperty) == 0)
{
//send to datamodel
isData = 1;
}
if (stricmp(pstProperty, "user_data") == 0 ||
stricmp(pstProperty, "userdata") == 0 ||
stricmp(pstProperty, "display_function_data") == 0 ||
stricmp(pstProperty, "data") == 0)
{
/* in this case set_user_data_property
* directly uses the third position in the stack
* to get the variable which is to be set in
* the user_data property (any data type is allowed) S. Steer */
pvData = (void*)piAddr3; /*position in the stack */
iRows3 = -1; /*unused */
iCols3 = -1; /*unused */
iType3 = -1;
}
else
{
sciErr = getVarType(pvApiCtx, piAddr3, &iType3);
if (sciErr.iErr)
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1);
return 1;
}
switch (iType3)
{
case sci_matrix :
sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows3, &iCols3, (double**)&pvData);
break;
case sci_boolean :
sciErr = getMatrixOfBoolean(pvApiCtx, piAddr3, &iRows3, &iCols3, (int**)&pvData);
break;
case sci_handles :
sciErr = getMatrixOfHandle(pvApiCtx, piAddr3, &iRows3, &iCols3, (long long**)&pvData);
break;
case sci_strings :
if (strcmp(pstProperty, "tics_labels") != 0 && strcmp(pstProperty, "auto_ticks") != 0 && strcmp(pstProperty, "tight_limits") != 0 &&
strcmp(pstProperty, "axes_visible") != 0 && strcmp(pstProperty, "axes_reverse") != 0 &&
strcmp(pstProperty, "text") != 0 && stricmp(pstProperty, "string") != 0 &&
stricmp(pstProperty, "tooltipstring") != 0 && stricmp(pstProperty, "ticks_format") != 0) /* Added for uicontrols */
{
if (isScalar(pvApiCtx, piAddr3) == 0)
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, iPos + 1);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr3, (char**)&pvData))
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1);
return 1;
}
iRows3 = (int)strlen((char*)pvData);
iCols3 = 1;
isMatrixOfString = 0;
}
else
{
isMatrixOfString = 1;
getAllocatedMatrixOfString(pvApiCtx, piAddr3, &iRows3, &iCols3, (char***)&pvData);
}
break;
case sci_list :
iCols3 = 1;
sciErr = getListItemNumber(pvApiCtx, piAddr3, &iRows3);
pvData = (void*)piAddr3; /* In this case l3 is the list position in stack */
break;
default :
pvData = (void*)piAddr3; /* In this case l3 is the list position in stack */
break;
}
if (sciErr.iErr)
{
freeAllocatedSingleString(pstProperty);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1);
return 1;
}
}
setStatus = callSetProperty(pvApiCtx, iObjUID, pvData, iType3, iRows3, iCols3, pstProperty);
if (iType3 == sci_strings)
{
//free allacted data
if (isMatrixOfString == 1)
{
freeAllocatedMatrixOfString(iRows3, iCols3, (char**)pvData);
}
else
{
freeAllocatedSingleString((char*)pvData);
}
}
freeAllocatedSingleString(pstProperty);
}
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_archive_compress(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
char *pStVarOne = NULL;
char *pStVarOneExpanded = NULL;
int *piAddressVarTwo = NULL;
char **pStVarTwo = NULL;
int m1 = 0;
int n1 = 0;
int i = 0;
int *piAddressVarThree = NULL;
char *pStVarThree = NULL;
char **file_list = NULL;
/* Check Input & Output parameters */
CheckRhs(3, 3);
CheckLhs(1, 2);
int result = 0;
int *error = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0 || isScalar(pvApiCtx, piAddressVarOne) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isDoubleType(pvApiCtx, piAddressVarTwo))
{
if (isEmptyMatrix(pvApiCtx, piAddressVarTwo))
{
if (createEmptyMatrix(pvApiCtx, Rhs + 2))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
if (isStringType(pvApiCtx, piAddressVarTwo) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 2);
return 0;
}
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarTwo, &m1, &n1, &pStVarTwo))
{
freeAllocatedMatrixOfString(m1, n1, pStVarTwo);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarThree) == 0 || isScalar(pvApiCtx, piAddressVarThree) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pStVarOne))
{
if (pStVarOne)
{
freeAllocatedSingleWideString(pStVarOne);
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &pStVarThree))
{
if (pStVarThree)
{
freeAllocatedSingleWideString(pStVarThree);
}
freeAllocatedSingleString(pStVarOne);
freeAllocatedSingleString(pStVarTwo);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
int size = 0;
while(i < (m1*n1))
{
size++;
if(file_list!=NULL)
{
file_list = (char**)REALLOC(file_list,sizeof(char*)*(size));
}
else
{
file_list = (char**)MALLOC(sizeof(char*)*(size));
}
file_list[size-1] = (char*)MALLOC(sizeof(char)*512);
strcpy(file_list[size-1],expandPathVariable(pStVarTwo[i]));
i++;
}
i = 0;
if(strlen(pStVarThree)>2)
{
Scierror(999, _("%s: Sorry unrecognised format type.\n"), fname);
return 0;
}
while(i<strlen(pStVarThree))
{
if(pStVarThree[i]!='Z' && pStVarThree[i]!='j' && pStVarThree[i]!='y' && pStVarThree[i]!='z')
{
Scierror(999, _("%s: Sorry unrecognised format type.\n"), fname);
return 0;
}
i++;
}
result = archive_compress(pStVarOne,file_list,size,pStVarThree,&error);
if(error == 1)
{
Scierror(999, _("%s: Sorry the file could not be opened.\n"), fname);
return 0;
}
if(error == 2)
{
Scierror(999, _("%s: Sorry the file header could not be read\n"), fname);
return 0;
}
if(error == 3)
{
Scierror(999, _("%s: Sorry the file header could not be written.\n"), fname);
return 0;
}
freeAllocatedSingleString(pStVarOne);
freeAllocatedSingleString(pStVarTwo);
createScalarInteger32(pvApiCtx, Rhs + 1, result);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_figure(char * fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddr = NULL;
int iFig = 0;
int iRhs = nbInputArgument(pvApiCtx);
int iId = 0;
int iPos = 0;
int i = 0;
int iAxes = 0;
int iPropertyOffset = 0;
BOOL bDoCreation = TRUE;
BOOL bVisible = TRUE; // Create a visible figure by default
BOOL bDockable = TRUE; // Create a dockable figure by default
BOOL bDefaultAxes = TRUE; // Create an Axes by default
double* figureSize = NULL;
double* axesSize = NULL;
double* position = NULL;
double val[4];
BOOL bMenuBar = TRUE;
BOOL bToolBar = TRUE;
BOOL bInfoBar = TRUE;
BOOL bResize = TRUE;
int iMenubarType = 1; // Create a 'figure' menubar by default
int iToolbarType = 1; // Create a 'figure' toolbar by default
double dblId = 0;
BOOL status = FALSE;
//figure(num) -> scf(num)
//figure() -> scf()
//figure(x, "...", ...)
// figure()
if (iRhs == 0) // Auto ID
{
iId = getValidDefaultFigureId();
iFig = createNewFigureWithAxes();
setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int, 1);
iAxes = setDefaultProperties(iFig, TRUE);
initBar(iFig, bMenuBar, bToolBar, bInfoBar);
createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig));
AssignOutputVariable(pvApiCtx, 1) = iRhs + 1;
ReturnArguments(pvApiCtx);
return 0;
}
if (iRhs == 1)
{
//figure(x);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isVarMatrixType(pvApiCtx, piAddr) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 1);
return 0;
}
if (getScalarDouble(pvApiCtx, piAddr, &dblId))
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
iId = (int)(dblId + 0.5); //avoid 1.999 -> 1
//get current fig from id
iFig = getFigureFromIndex(iId);
if (iFig == 0) // Figure does not exists, create a new one
{
iFig = createNewFigureWithAxes();
setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int, 1);
iAxes = setDefaultProperties(iFig, TRUE);
}
initBar(iFig, bMenuBar, bToolBar, bInfoBar);
createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig));
AssignOutputVariable(pvApiCtx, 1) = iRhs + 1;
ReturnArguments(pvApiCtx);
return 0;
}
// Prepare property analysis
if (iRhs % 2 == 0)
{
//get highest value of winsid to create the new windows @ + 1
iId = getValidDefaultFigureId();
iPos = 0;
}
else
{
iPos = 1;
//figure(x, ...);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isVarMatrixType(pvApiCtx, piAddr) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 1);
return 0;
}
if (getScalarDouble(pvApiCtx, piAddr, &dblId))
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
iId = (int)(dblId + 0.5); //avoid 1.999 -> 1
//get current fig from id
iFig = getFigureFromIndex(iId);
if (iFig != 0) // Figure already exists
{
bDoCreation = FALSE;
}
}
if (bDoCreation)
{
int* piAddrProp = NULL;
char* pstProName = NULL;
int* piAddrData = NULL;
for (i = iPos + 1 ; i <= iRhs ; i += 2)
{
//get property name
sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrProp);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddrProp, &pstProName))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i);
return 1;
}
if (stricmp(pstProName, "dockable") != 0 &&
stricmp(pstProName, "toolbar") != 0 &&
stricmp(pstProName, "menubar") != 0 &&
stricmp(pstProName, "default_axes") != 0 &&
stricmp(pstProName, "visible") != 0 &&
stricmp(pstProName, "figure_size") != 0 &&
stricmp(pstProName, "axes_size") != 0 &&
stricmp(pstProName, "position") != 0 &&
stricmp(pstProName, "menubar_visible") != 0 &&
stricmp(pstProName, "toolbar_visible") != 0 &&
stricmp(pstProName, "resize") != 0 &&
stricmp(pstProName, "infobar_visible") != 0)
{
freeAllocatedSingleString(pstProName);
continue;
}
//get address of value on stack
sciErr = getVarAddressFromPosition(pvApiCtx, i + 1, &piAddrData);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
//check property value to compatibility
if (stricmp(pstProName, "dockable") == 0)
{
bDockable = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bDockable == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "dockable", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "toolbar") == 0)
{
char* pstVal = NULL;
if (isStringType(pvApiCtx, piAddrData) == FALSE || isScalar(pvApiCtx, piAddrData) == FALSE)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i);
freeAllocatedSingleString(pstProName);
}
if (getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
if (stricmp(pstVal, "none") == 0)
{
iToolbarType = 0;
}
else if (stricmp(pstVal, "figure") == 0)
{
iToolbarType = 1;
}
else
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "toolbar", "none", "figure");
freeAllocatedSingleString(pstProName);
freeAllocatedSingleString(pstVal);
return 1;
}
freeAllocatedSingleString(pstVal);
}
else if (stricmp(pstProName, "menubar") == 0)
{
char* pstVal = NULL;
if (isStringType(pvApiCtx, piAddrData) == FALSE || isScalar(pvApiCtx, piAddrData) == FALSE)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
if (stricmp(pstVal, "none") == 0)
{
iMenubarType = 0;
}
else if (stricmp(pstVal, "figure") == 0)
{
iMenubarType = 1;
}
else
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "menubar", "none", "figure");
freeAllocatedSingleString(pstProName);
freeAllocatedSingleString(pstVal);
return 1;
}
freeAllocatedSingleString(pstVal);
}
else if (stricmp(pstProName, "default_axes") == 0)
{
bDefaultAxes = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bDefaultAxes == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "default_axes", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "visible") == 0)
{
bVisible = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bVisible == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "visible", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "figure_size") == 0)
{
int iRows = 0;
int iCols = 0;
if (isDoubleType(pvApiCtx, piAddrData) == FALSE)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A double vector expected.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &figureSize);
if (iRows * iCols != 2)
{
Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "figure_size", 2);
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "axes_size") == 0)
{
int iRows = 0;
int iCols = 0;
if (isDoubleType(pvApiCtx, piAddrData) == FALSE)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A double vector expected.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &axesSize);
if (iRows * iCols != 2)
{
Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "axes_size", 2);
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "position") == 0)
{
int iRows = 0;
int iCols = 0;
double* pdbl = NULL;
if (isDoubleType(pvApiCtx, piAddrData))
{
getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &pdbl);
if (iRows * iCols != 4)
{
Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "position", 4);
freeAllocatedSingleString(pstProName);
return 1;
}
position = pdbl;
axesSize = (pdbl + 2);
}
else if (isStringType(pvApiCtx, piAddrData) && isScalar(pvApiCtx, piAddrData))
{
char* pstVal = NULL;
int iVal = 0;
if (getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
iVal = sscanf(pstVal, "%lf|%lf|%lf|%lf", &val[0], &val[1], &val[2], &val[3]);
freeAllocatedSingleString(pstVal);
if (iVal != 4)
{
Scierror(999, _("Wrong value for '%s' property: string or 1 x %d real row vector expected.\n"), "position", 4);
freeAllocatedSingleString(pstProName);
return 1;
}
position = val;
axesSize = (val + 2);
}
else
{
Scierror(999, _("Wrong value for '%s' property: string or 1 x %d real row vector expected.\n"), "position", 4);
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "resize") == 0)
{
bResize = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bResize == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "resize", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "menubar_visible") == 0)
{
bMenuBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bMenuBar == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "menubar_visible", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "toolbar_visible") == 0)
{
bToolBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bToolBar == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "toolbar_visible", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
else if (stricmp(pstProName, "infobar_visible") == 0)
{
bInfoBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
if (bInfoBar == -1)
{
Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "infobar_visible", "on", "off");
freeAllocatedSingleString(pstProName);
return 1;
}
}
freeAllocatedSingleString(pstProName);
}
iFig = createFigure(bDockable, iMenubarType, iToolbarType, bDefaultAxes, bVisible);
setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int, 1);
iAxes = setDefaultProperties(iFig, bDefaultAxes);
}
//set(iFig, iPos, iPos + 1)
for (i = iPos + 1 ; i <= iRhs ; i += 2)
{
int isMatrixOfString = 0;
int* piAddrProp = NULL;
char* pstProName = NULL;
int* piAddrData = NULL;
int iRows = 0;
int iCols = 0;
void* _pvData = NULL;
int iType = 0;
//get property name
sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrProp);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddrProp, &pstProName))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i);
return 1;
}
if (bDoCreation && (
stricmp(pstProName, "dockable") == 0 ||
stricmp(pstProName, "toolbar") == 0 ||
stricmp(pstProName, "menubar") == 0 ||
stricmp(pstProName, "default_axes") == 0 ||
stricmp(pstProName, "visible") == 0 ||
stricmp(pstProName, "figure_size") == 0 ||
stricmp(pstProName, "axes_size") == 0 ||
stricmp(pstProName, "position") == 0 ||
stricmp(pstProName, "resize") == 0 ||
stricmp(pstProName, "menubar_visible") == 0 ||
stricmp(pstProName, "toolbar_visible") == 0 ||
stricmp(pstProName, "infobar_visible") == 0))
{
// Already set creating new figure
// but let the set_ function fail if figure already exists
freeAllocatedSingleString(pstProName);
continue;
}
//get address of value on stack
sciErr = getVarAddressFromPosition(pvApiCtx, i + 1, &piAddrData);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i + 1);
freeAllocatedSingleString(pstProName);
return 1;
}
getVarType(pvApiCtx, piAddrData, &iType);
if ((strcmp(pstProName, "user_data") == 0) || (stricmp(pstProName, "userdata") == 0))
{
/* in this case set_user_data_property
* directly uses the third position in the stack
* to get the variable which is to be set in
* the user_data property (any data type is allowed) S. Steer */
_pvData = (void*)piAddrData; /*position in the stack */
iRows = -1; /*unused */
iCols = -1; /*unused */
iType = -1;
}
else
{
switch (iType)
{
case sci_matrix :
getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, (double**)&_pvData);
break;
case sci_boolean :
getMatrixOfBoolean(pvApiCtx, piAddrData, &iRows, &iCols, (int**)&_pvData);
break;
case sci_handles :
getMatrixOfHandle(pvApiCtx, piAddrData, &iRows, &iCols, (long long**)&_pvData);
break;
case sci_strings :
if ( strcmp(pstProName, "tics_labels") != 0 && strcmp(pstProName, "auto_ticks") != 0 &&
strcmp(pstProName, "axes_visible") != 0 && strcmp(pstProName, "axes_reverse") != 0 &&
strcmp(pstProName, "text") != 0 && stricmp(pstProName, "string") != 0 &&
stricmp(pstProName, "tooltipstring") != 0) /* Added for uicontrols */
{
if (getAllocatedSingleString(pvApiCtx, piAddrData, (char**)&_pvData))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 3);
freeAllocatedSingleString(pstProName);
return 1;
}
iRows = (int)strlen((char*)_pvData);
iCols = 1;
}
else
{
isMatrixOfString = 1;
if (getAllocatedMatrixOfString(pvApiCtx, piAddrData, &iRows, &iCols, (char***)&_pvData))
{
Scierror(999, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
freeAllocatedSingleString(pstProName);
return 1;
}
}
break;
case sci_list :
iCols = 1;
getListItemNumber(pvApiCtx, piAddrData, &iRows);
_pvData = (void*)piAddrData; /* In this case l3 is the list position in stack */
break;
default :
_pvData = (void*)piAddrData; /* In this case l3 is the list position in stack */
break;
}
}
callSetProperty(pvApiCtx, iFig, _pvData, iType, iRows, iCols, pstProName);
// If backgroundcolor is set :
// * add it to colormap => performed by callSetProperty
// * set background to index => performed by callSetProperty
// * copy value into axes background property
if (stricmp(pstProName, "backgroundcolor") == 0 && iAxes > 0)
{
int iBackground = 0;
int *piBackground = &iBackground;
getGraphicObjectProperty(iFig, __GO_BACKGROUND__, jni_int, (void **)&piBackground);
setGraphicObjectProperty(iAxes, __GO_BACKGROUND__, piBackground, jni_int, 1);
}
freeAllocatedSingleString(pstProName);
if (iType == sci_strings)
{
//free allacted data
if (isMatrixOfString == 1)
{
freeAllocatedMatrixOfString(iRows, iCols, (char**)_pvData);
}
else
{
freeAllocatedSingleString((char*)_pvData);
}
}
}
if (position)
{
int pos[2];
pos[0] = (int)position[0];
pos[1] = (int)position[1];
setGraphicObjectProperty(iFig, __GO_POSITION__, pos, jni_int_vector, 2);
}
//axes_size
if (axesSize)
{
int axes[2];
axes[0] = (int)axesSize[0];
axes[1] = (int)axesSize[1];
setGraphicObjectProperty(iFig, __GO_AXES_SIZE__, axes, jni_int_vector, 2);
}
else //no size, use default axes_size
{
int* piAxesSize = NULL;
getGraphicObjectProperty(getFigureModel(), __GO_AXES_SIZE__, jni_int_vector, (void **)&piAxesSize);
setGraphicObjectProperty(iFig, __GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2);
releaseGraphicObjectProperty(__GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2);
}
initBar(iFig, bMenuBar, bToolBar, bInfoBar);
if (axesSize == NULL && figureSize) //figure_size
{
int figure[2];
figure[0] = (int)figureSize[0];
figure[1] = (int)figureSize[1];
setGraphicObjectProperty(iFig, __GO_SIZE__, figure, jni_int_vector, 2);
}
setGraphicObjectProperty(iFig, __GO_RESIZE__, (void*)&bResize, jni_bool, 1);
//return new created fig
createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig));
AssignOutputVariable(pvApiCtx, 1) = iRhs + 1;
ReturnArguments(pvApiCtx);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_x_choose_modeless(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddritemsAdr = NULL;
int* piAddrmessageAdr = NULL;
int* piAddrbuttonLabelAdr = NULL;
double* userValueAdr = NULL;
int nbRow = 0, nbCol = 0;
int nbRowItems = 0, nbColItems = 0;
int messageBoxID = 0;
char **itemsAdr = NULL;
char **buttonLabelAdr = NULL;
char **messageAdr = NULL;
int userValue = 0;
CheckInputArgument(pvApiCtx, 2, 3);
CheckOutputArgument(pvApiCtx, 0, 1);
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddritemsAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddritemsAdr, &nbRowItems, &nbColItems, &itemsAdr))
{
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;
}
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRow, &nbCol, &messageAdr))
{
freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
}
else
{
freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
return FALSE;
}
/* Create the Java Object */
messageBoxID = createMessageBox();
/* Title is a default title */
setMessageBoxTitle(messageBoxID, _("Scilab Choose Message"));
/* Message */
setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbCol * nbRow);
/* ListBox Items */
setMessageBoxListBoxItems(messageBoxID, itemsAdr, nbColItems * nbRowItems);
/* Modality */
setMessageBoxModal(messageBoxID, FALSE);
freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
freeAllocatedMatrixOfString(nbRow, nbCol, messageAdr);
if (nbInputArgument(pvApiCtx) == 3)
{
if (VarType(3) == sci_strings)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrbuttonLabelAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 3.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonLabelAdr, &nbRow, &nbCol, &buttonLabelAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow*nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
return FALSE;
}
setMessageBoxButtonsLabels(messageBoxID, buttonLabelAdr, nbCol * nbRow);
freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr);
}
/* Display it and wait for a user input */
messageBoxDisplayAndWait(messageBoxID);
/* Read the user answer */
userValue = getMessageBoxSelectedItem(messageBoxID);
nbRow = 1;
nbCol = 1;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &userValueAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*userValueAdr = userValue;
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return TRUE;
}
int ScilabGateway::evalString(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int * addr = 0;
int row;
int col;
char ** code = 0;
ScilabStringStackAllocator * allocator = 0;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 1, 1);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: string expected."), 1);
}
err = getVarDimension(pvApiCtx, addr, &row, &col);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if ((row < 1 || col != 1) && (col < 1 || row != 1))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimension for argument #%d: A row or a column expected."), 1);
}
if (getAllocatedMatrixOfString(pvApiCtx, addr, &row, &col, &code))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (Rhs == 2)
{
int val;
err = getVarAddressFromPosition(pvApiCtx, 2, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isBooleanType(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A boolean expected."), 2);
}
if (!isScalar(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A single boolean expected."), 2);
}
getScalarBoolean(pvApiCtx, addr, &val);
if (val)
{
allocator = new ScilabStringStackAllocator(pvApiCtx, Rhs + 1);
}
}
try
{
env.evalString(const_cast<const char **>(code), row * col, allocator);
}
catch (std::exception & /*e*/)
{
freeAllocatedMatrixOfString(row, col, code);
throw;
}
if (allocator)
{
delete allocator;
LhsVar(1) = Rhs + 1;
}
else
{
LhsVar(1) = 0;
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_gettext(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
char* pstDomain = NULL;
char **TranslatedStrings = NULL;
int m = 0;
int n = 0;
char **StringsToTranslate = NULL;
int i = 0;
int iCurrentRhs = 1;
int iRhs = nbInputArgument(pvApiCtx);
int iLhs = nbOutputArgument(pvApiCtx);
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
if (iRhs == 2)
{
//get domain name
sciErr = getVarAddressFromPosition(pvApiCtx, iCurrentRhs, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iCurrentRhs);
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0 || isScalar(pvApiCtx, piAddressVarOne) == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, iCurrentRhs);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pstDomain))
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
iCurrentRhs++;
}
sciErr = getVarAddressFromPosition(pvApiCtx, iCurrentRhs, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iCurrentRhs);
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
freeAllocatedSingleString(pstDomain);
return 0;
}
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarOne, &m, &n, &StringsToTranslate) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
freeAllocatedSingleString(pstDomain);
return 0;
}
TranslatedStrings = (char **)MALLOC(sizeof(char*) * (m * n));
if (TranslatedStrings == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
freeAllocatedSingleString(pstDomain);
freeAllocatedMatrixOfString(m, n, StringsToTranslate);
StringsToTranslate = NULL;
return 0;
}
for (i = 0; i < m * n; i++)
{
if (strcmp(StringsToTranslate[i], "") == 0)
{
TranslatedStrings[i] = strdup("");
}
else
{
//if pstDomain is NULL, default domain will be use
TranslatedStrings[i] = convertString_dgettext(pstDomain, StringsToTranslate[i]);
}
}
freeAllocatedSingleString(pstDomain);
freeAllocatedMatrixOfString(m, n, StringsToTranslate);
StringsToTranslate = NULL;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, TranslatedStrings);
freeArrayOfString(TranslatedStrings, m * n);
TranslatedStrings = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
static int serialize_string(void *_pvCtx, int *_piAddr, int **_piBuffer, int *_piBufferSize)
{
int iErr = 0;
int i = 0;
int iRows = 0;
int iCols = 0;
char **pstData = NULL;
char *p = NULL;
int *piOut = NULL;
int *piOutLen = NULL;
int iOutLen = 0;
iErr = getAllocatedMatrixOfString(_pvCtx, _piAddr, &iRows, &iCols, &pstData);
if (iErr)
{
return 1;
}
for (i = 0; i < iRows * iCols; i++)
{
iOutLen += (int)strlen(pstData[i]);
}
if (iOutLen % 4)
{
iOutLen = iOutLen / (sizeof(int) / sizeof(char)) + 1;
}
else
{
iOutLen = iOutLen / (sizeof(int) / sizeof(char));
}
//4 for header and size of each string
iOutLen += 4 + iRows * iCols;
piOut = (int *)MALLOC(iOutLen * sizeof(int));
if (piOut == NULL)
{
return 1;
}
piOut[0] = sci_strings;
piOut[1] = iRows;
piOut[2] = iCols;
piOut[3] = 0; //not complex
piOutLen = piOut + 4;
for (i = 0; i < iRows * iCols; i++)
{
piOutLen[i] = (int)strlen(pstData[i]);
}
p = (char *)(piOut + 4 + iRows * iCols);
for (i = 0; i < iRows * iCols; i++)
{
memcpy(p, pstData[i], piOutLen[i]);
p += piOutLen[i];
}
*_piBuffer = piOut;
*_piBufferSize = iOutLen;
freeAllocatedMatrixOfString(iRows, iCols, pstData);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_dgettext(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int *piAddressVarTwo = NULL;
CheckRhs(2, 2);
CheckLhs(1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
}
if (isStringType(pvApiCtx, piAddressVarOne) && isStringType(pvApiCtx, piAddressVarTwo))
{
char *domain = NULL;
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999, "%s: Wrong size for input argument #%d: A string expected.\n", fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &domain) == 0)
{
char **stringsToTranslate = NULL;
char **TranslatedStrings = NULL;
int m = 0, n = 0;
int i = 0;
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarTwo, &m, &n, &stringsToTranslate) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
TranslatedStrings = (char **)MALLOC(sizeof(char*) * (m * n));
if (TranslatedStrings == NULL)
{
freeAllocatedMatrixOfString(m, n, stringsToTranslate);
stringsToTranslate = NULL;
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
for (i = 0; i < m * n; i++)
{
if (strcmp(stringsToTranslate[i], "") == 0)
{
TranslatedStrings[i] = strdup("");
}
else
{
TranslatedStrings[i] = convertString_dgettext(domain, stringsToTranslate[i]);
}
}
freeAllocatedMatrixOfString(m, n, stringsToTranslate);
stringsToTranslate = NULL;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n,
(const char *const *)TranslatedStrings);
freeArrayOfString(TranslatedStrings, m * n);
TranslatedStrings = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
else
{
if (isStringType(pvApiCtx, piAddressVarOne))
{
Scierror(999, "%s: Wrong type for input argument #%d: String expected.\n", fname, 2);
}
else
{
Scierror(999, "%s: Wrong type for input argument #%d: String expected.\n", fname, 1);
}
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_progressionbar(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrhandleAdr = NULL;
long long* handleAdr = NULL;
int* piAddrmessageAdr = NULL;
long long* stkAdr = NULL;
int iProgressionbarUID = 0;
int nbRow = 0, nbCol = 0;
int nbRowMessage = 0, nbColMessage = 0;
char **messageAdr = NULL;
int iValue = 0;
unsigned long GraphicHandle = 0;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhandleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (nbInputArgument(pvApiCtx) == 1)
{
if ((checkInputArgumentType(pvApiCtx, 1, sci_handles))) /* ProgressionBar to update */
{
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return FALSE;
}
}
else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) /* Message to display */
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
{
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: A graphic handle or a string expected.\n"), fname, 1);
return FALSE;
}
if (handleAdr == 0)
{
/* Create a new ProgressionBar */
iProgressionbarUID = createGraphicObject(__GO_PROGRESSIONBAR__);
GraphicHandle = getHandle(iProgressionbarUID);
setGraphicObjectProperty(iProgressionbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
}
else
{
GraphicHandle = (unsigned long) * (handleAdr);
iProgressionbarUID = getObjectFromHandle(GraphicHandle);
setGraphicObjectProperty(iProgressionbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
}
}
else if (nbInputArgument(pvApiCtx) == 2)
{
if ((checkInputArgumentType(pvApiCtx, 1, sci_handles)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings))) /* progressionbar(id,mes) */
{
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return FALSE;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
GraphicHandle = (unsigned long) * handleAdr;
iProgressionbarUID = getObjectFromHandle(GraphicHandle);
setGraphicObjectProperty(iProgressionbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
setGraphicObjectProperty(iProgressionbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
}
else
{
Scierror(999, _("%s: Wrong input arguments: '%s' expected.\n"), fname, "(id, mes)");
return FALSE;
}
}
if (nbOutputArgument(pvApiCtx) == 1)
{
nbRow = 1;
nbCol = 1;
sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*stkAdr = (long long)GraphicHandle;
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
AssignOutputVariable(pvApiCtx, 1) = 0;
}
ReturnArguments(pvApiCtx);
return TRUE;
}
int ScilabGateway::deff(char * fname, const int envId, void * pvApiCtx)
{
static int ONE = 1;
static int TWO = 2;
static int THREE = 3;
SciErr err;
char ** names[] = {0, 0, 0};
int ret = 0;
std::ostringstream os;
int * addr[] = {0, 0, 0};
int rows[] = {0, 0, 0};
int cols[] = {0, 0, 0};
int error = 0;
char * cwd = 0;
CheckInputArgument(pvApiCtx, 3, 3);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper & helper = env.getOptionsHelper();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
if (pCall == nullptr)
{
symbol::Context* ctx = symbol::Context::getInstance();
types::InternalType* pIT = ctx->get(symbol::Symbol(L"#_deff_wrapper"));
if (pIT && pIT->isCallable())
{
pCall = pIT->getAs<types::Callable>();
}
else
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
for (int i = 0; i < 3; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i + 1, &(addr[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr[i]))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), 1);
}
err = getVarDimension(pvApiCtx, addr[i], &(rows[i]), &(cols[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
if (rows[0] != 1 || cols[0] != 1)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions for input argument #%d: A single string expected."), 1);
}
if (rows[1] != rows[2] || cols[1] != cols[2])
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions: arguments #2 and #3 must have the same."));
}
for (int i = 0; i < 3; i++)
{
if (getAllocatedMatrixOfString(pvApiCtx, addr[i], &(rows[i]), &(cols[i]), &(names[i])))
{
for (int j = 0; j < i; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
cwd = scigetcwd(&error);
if (error)
{
FREE(cwd);
cwd = 0;
}
try
{
ret = env.loadclass(names[0][0], cwd, false, helper.getAllowReload());
}
catch (std::exception & /*e*/)
{
FREE(cwd);
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw;
}
FREE(cwd);
for (int i = 0; i < rows[1] * cols[1]; i++)
{
//call #_deff_wrapper
types::typed_list in, out;
types::optional_list opt;
//name
in.push_back(new types::String(names[2][i]));
//protopype
os.str("");
os << "y=" << names[2][i] << "(varargin)" << std::flush;
in.push_back(new types::String(os.str().c_str()));
//body
os.str("");
os << "y=invoke_lu(int32(" << ret << "),int32(" << envId << "),\"" << names[1][i] << "\",varargin)" << std::flush;
in.push_back(new types::String(os.str().c_str()));
ast::ExecVisitor exec;
if (pCall->call(in, opt, 0, out, &exec) != types::Function::OK)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
}
for (int i = 0; i < 3; i++)
{
freeAllocatedMatrixOfString(rows[0], cols[0], names[i]);
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
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_toolbar(char *fname, unsigned long l)
{
SciErr sciErr;
int* piAddr1 = NULL;
int* piStkAdr = NULL;
int* piAddrstkAdr = NULL;
long long* stkAdr = NULL;
int* piAddrparam = NULL;
int nbCol = 0;
int nbRow = 0;
char *Output = NULL;
char **param = NULL;
int figNum = -2;
int iIsVisible = 0;
int *piIsVisible = NULL;
int iParentUID = 0;
int iParentType = -1;
int *piParentType = &iParentType;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
/* Figure number */
if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr1, &nbRow, &nbCol, &piStkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 1);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
return FALSE;
}
figNum = *piStkAdr;
if (figNum < -1)
{
Scierror(999, _("%s: Wrong value for input argument #%d: Must be > %d expected.\n"), fname, 1, -1);
return FALSE;
}
if (figNum != -1) /* Check that the figure exists */
{
if (getFigureFromIndex(figNum) == 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: 'Graphic Window Number %d' does not exist.\n"), fname, 1, figNum);
return FALSE;
}
}
if (figNum == -1)
{
iParentUID = getConsoleIdentifier();
}
else
{
iParentUID = getFigureFromIndex(figNum);
}
}
else if (checkInputArgumentType(pvApiCtx, 1, sci_handles))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrstkAdr, &nbRow, &nbCol, &stkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
if (nbRow * nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return FALSE;
}
iParentUID = getObjectFromHandle((long) * stkAdr);
if (iParentUID == 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: this handle does not exist.\n"), fname, 1);
return FALSE;
}
getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
if (iParentType != __GO_FIGURE__)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real or a Figure handle expected.\n"), fname, 1);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real or a Figure handle expected.\n"), fname, 1);
return FALSE;
}
if (nbInputArgument(pvApiCtx) == 2) /* New status */
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrparam);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrparam, &nbRow, &nbCol, ¶m))
{
Scierror(202, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, param);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
if ((strcmp(param[0], "off") == 0) || (strcmp(param[0], "on") == 0))
{
iIsVisible = strcmp(param[0], "on") == 0;
if (iParentUID != getConsoleIdentifier() || getScilabMode() == SCILAB_STD)
{
setGraphicObjectProperty(iParentUID, __GO_TOOLBAR_VISIBLE__, &iIsVisible, jni_bool, 1);
}
freeAllocatedMatrixOfString(nbRow, nbCol, param);
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, param);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "on", "off");
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
return FALSE;
}
}
/* Returned value */
piIsVisible = &iIsVisible;
getGraphicObjectProperty(iParentUID, __GO_TOOLBAR_VISIBLE__, jni_bool, (void **)&piIsVisible);
if (iIsVisible)
{
Output = strdup("on");
}
else
{
Output = strdup("off");
}
nbCol = 1;
nbRow = (int)strlen(Output);
if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, Output))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
if (Output)
{
FREE(Output);
Output = NULL;
}
ReturnArguments(pvApiCtx);
return TRUE;
}
int ScilabGateway::import(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int rows, cols;
char ** className = 0;
std::string * name = 0;
int named = 1;
int * addr = 0;
int ret = 0;
int nbArgs = Rhs;
int error = 0;
char * cwd = 0;
CheckInputArgumentAtLeast(pvApiCtx, 1);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
OptionsHelper & helper = env.getOptionsHelper();
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
err = getVarAddressFromPosition(pvApiCtx, Rhs, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (isBooleanType(pvApiCtx, addr))
{
nbArgs = Rhs - 1;
if (getScalarBoolean(pvApiCtx, addr, &named))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
if (nbArgs == 1)
{
err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), 1);
}
if (getAllocatedMatrixOfString(pvApiCtx, addr, &rows, &cols, &className))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
else
{
className = (char**)MALLOC(sizeof(char *) * nbArgs);
for (int i = 1; i <= nbArgs; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i, &addr);
if (err.iErr)
{
freeAllocatedMatrixOfString(1, i, className);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr))
{
freeAllocatedMatrixOfString(1, i, className);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), i);
}
if (getAllocatedSingleString(pvApiCtx, addr, &(className[i - 1])))
{
freeAllocatedMatrixOfString(1, i, className);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
rows = 1;
cols = nbArgs;
}
if (named)
{
name = new std::string[rows * cols];
for (int i = 0; i < rows * cols; i++)
{
name[i] = std::string(className[i]);
if (helper.getUseLastName())
{
std::size_t pos = name[i].find_last_of('.');
if (pos != std::string::npos)
{
if (pos == name[i].size() - 1)
{
freeAllocatedMatrixOfString(rows, cols, className);
delete[] name;
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("The class name cannot end with a dot."));
}
name[i] = name[i].substr(pos + 1);
}
}
else
{
std::size_t pos = name[i].find_first_of('.');
if (pos != std::string::npos)
{
if (pos == 0)
{
freeAllocatedMatrixOfString(rows, cols, className);
delete[] name;
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("The class name cannot start with a dot."));
}
name[i] = name[i].substr(0, pos);
}
}
if (isNamedVarExist(pvApiCtx, name[i].c_str()))
{
addr = 0;
err = getVarAddressFromName(pvApiCtx, name[i].c_str(), &addr);
if (err.iErr || addr == 0 || !ScilabObjects::isValidExternal(addr, pvApiCtx) || ScilabObjects::getEnvironmentId(addr, pvApiCtx) != envId)
{
freeAllocatedMatrixOfString(rows, cols, className);
delete[] name;
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("A variable with this name is already existing"));
}
}
}
}
if (!named && rows * cols != Lhs)
{
freeAllocatedMatrixOfString(rows, cols, className);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Bad number of output arguments"), __FILE__, __LINE__);
}
const int type = helper.getNewAllowed() ? EXTERNAL_CLASS : EXTERNAL_OBJECT;
cwd = scigetcwd(&error);
if (error)
{
FREE(cwd);
cwd = 0;
}
for (int i = 0; i < rows * cols; i++)
{
try
{
ret = env.loadclass(className[i], cwd, static_cast<bool>(named), helper.getAllowReload());
}
catch (std::exception & e)
{
FREE(cwd);
freeAllocatedMatrixOfString(rows, cols, className);
if (named)
{
delete[] name;
}
throw;
}
if (named)
{
try
{
ScilabObjects::createNamedEnvironmentObject(type, name[i].c_str(), ret, envId, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & e)
{
FREE(cwd);
freeAllocatedMatrixOfString(rows, cols, className);
delete[] name;
throw;
}
}
else
{
try
{
ScilabObjects::createEnvironmentObjectAtPos(type, Rhs + i + 1, ret, envId, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & e)
{
FREE(cwd);
freeAllocatedMatrixOfString(rows, cols, className);
env.removeobject(ret);
throw;
}
LhsVar(i + 1) = Rhs + i + 1;
}
}
FREE(cwd);
freeAllocatedMatrixOfString(rows, cols, className);
if (named)
{
delete[] name;
LhsVar(1) = 0;
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_stringbox(char * fname, void *pvApiCtx)
{
SciErr sciErr;
int* piAddrstackPointer = NULL;
long long* stackPointer = NULL;
char** strStackPointer = NULL;
double* pdblStackPointer = NULL;
int type = -1;
int *piType = &type;
int iParentAxes = 0;
int* piParentAxes = &iParentAxes;
double* textCorners = NULL;
int two = 2;
int four = 4;
double corners[4][2]; /* the four edges of the boundingRect */
/* The function should be called with stringbox(handle) */
CheckInputArgument(pvApiCtx, 1, 6);
CheckOutputArgument(pvApiCtx, 0, 1);
if (nbInputArgument(pvApiCtx) == 1)
{
int m;
int n;
/* A text handle should be specified */
int iTextUID = 0;
if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
return 0;
}
/* get the handle */
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &m, &n, &stackPointer);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: A ''%s'' handle expected.\n"), fname, 1, "Text");
return 1;
}
if (m * n != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A ''%s'' handle expected.\n"), fname, 1, "Text");
return 0;
}
/* Get the handle and check that this is a text handle */
iTextUID = getObjectFromHandle((long int) * stackPointer);
if (iTextUID == 0)
{
Scierror(999, _("%s: The handle is not valid.\n"), fname);
return 0;
}
getGraphicObjectProperty(iTextUID, __GO_TYPE__, jni_int, (void **)&piType);
if (type != __GO_LABEL__ && type != __GO_TEXT__)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
return 0;
}
getGraphicObjectProperty(iTextUID, __GO_PARENT_AXES__, jni_int, (void **)&piParentAxes);
updateTextBounds(iTextUID);
/*
* To do: performs a projection/unprojection to obtain the bounding box in object coordinates
* but using a rotation matrix corresponding to the default rotation angles (view == 2d)
*/
getGraphicObjectProperty(iTextUID, __GO_CORNERS__, jni_double_vector, (void **)&textCorners);
corners[1][0] = textCorners[0];
corners[1][1] = textCorners[1];
corners[0][0] = textCorners[3];
corners[0][1] = textCorners[4];
corners[3][0] = textCorners[6];
corners[3][1] = textCorners[7];
corners[2][0] = textCorners[9];
corners[2][1] = textCorners[10];
}
else if (nbInputArgument(pvApiCtx) == 2)
{
Scierror(999, _("%s: Wrong number of input arguments: %d or %d to %d expected.\n"), fname, 1, 3, 6);
return 0;
}
else
{
int iParentSubwinUID = getOrCreateDefaultSubwin();
char ** text = NULL;
int textNbRow;
int textNbCol;
double xPos;
double yPos;
double angle = DEFAULT_ANGLE;
int fontId;
int *pfontId = &fontId;
double fontSize;
double *pfontSize = &fontSize;
getGraphicObjectProperty(iParentSubwinUID, __GO_FONT_STYLE__, jni_int, (void**)&pfontId);
getGraphicObjectProperty(iParentSubwinUID, __GO_FONT_SIZE__, jni_double, (void **)&pfontSize);
/* Check that first argument is a string */
if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: 2D array of strings expected.\n"), fname, 1);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrstackPointer, &textNbRow, &textNbCol, &strStackPointer))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
return 1;
}
/* retrieve it */
text = strStackPointer;
/* Second and third arguments should be scalars */
if (getScalarFromStack(2, fname, &xPos, pvApiCtx) < 0)
{
freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
return 0;
}
if (getScalarFromStack(3, fname, &yPos, pvApiCtx) < 0)
{
freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
return 0;
}
if (nbInputArgument(pvApiCtx) >= 4)
{
/* angle is defined */
if (getScalarFromStack(4, fname, &angle, pvApiCtx) < 0)
{
freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
return 0;
}
}
if (nbInputArgument(pvApiCtx) >= 5)
{
double fontIdD;
/* font style is defined */
if (getScalarFromStack(5, fname, &fontIdD, pvApiCtx) < 0)
{
freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
return 0;
}
fontId = (int) fontIdD;
}
if (nbInputArgument(pvApiCtx) >= 6)
{
/* font size is defined */
if (getScalarFromStack(6, fname, &fontSize, pvApiCtx) < 0)
{
freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
return 0;
}
}
/* compute the box */
getTextBoundingBox(text, textNbRow, textNbCol, xPos, yPos, angle, fontId, fontSize, corners);
freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
}
/* copy everything into the lhs */
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, two, four, &pdblStackPointer);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
pdblStackPointer[0] = corners[1][0];
pdblStackPointer[1] = corners[1][1];
pdblStackPointer[2] = corners[0][0];
pdblStackPointer[3] = corners[0][1];
pdblStackPointer[4] = corners[3][0];
pdblStackPointer[5] = corners[3][1];
pdblStackPointer[6] = corners[2][0];
pdblStackPointer[7] = corners[2][1];
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
/*------------------------------------------------------------------------*/
int set_layout_options_property(void* _pvCtx, int iObjUID, void* _pvData, int valueType, int nbRow, int nbCol)
{
//[] or tlist
if (valueType == sci_matrix)
{
return clearLayoutOptions(iObjUID);
}
else
{
SciErr sciErr;
int i = 0;
int* piAddrList = (int*)_pvData;
int* piAddr = NULL;
int iRows = 0;
int iCols = 0;
char** pstField = NULL;
char* pstType = NULL;
sciErr = getListItemAddress(_pvCtx, piAddrList, 1, &piAddr);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
if (getAllocatedMatrixOfString(_pvCtx, piAddr, &iRows, &iCols, &pstField))
{
return SET_PROPERTY_ERROR;
}
pstType = pstField[0];
//depend of kind of tlist
if (strcmp(pstType, "OptNoLayout") == 0)
{
return clearLayoutOptions(iObjUID);
}
else if (strcmp(pstType, "OptBorder") == 0)
{
//arg2 -> double 1x2 -> int 1*2
int* piAddr2 = NULL;
int iRows2 = 0;
int iCols2 = 0;
double* pdblPadding = NULL;
int piPadding[2];
sciErr = getListItemAddress(_pvCtx, piAddrList, 2, &piAddr2);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblPadding);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
piPadding[0] = (int)pdblPadding[0];
piPadding[1] = (int)pdblPadding[1];
setGraphicObjectProperty(iObjUID, __GO_BORDER_OPT_PADDING__, piPadding, jni_int_vector, 2);
}
else if (strcmp(pstType, "OptGrid") == 0)
{
//arg2 -> double 1x2 -> int 1*2
//arg3 -> double 1x2 -> int 1*2
int* piAddr2 = NULL;
int iRows2 = 0;
int iCols2 = 0;
double* pdblGrid = NULL;
int piGrid[2];
int* piAddr3 = NULL;
int iRows3 = 0;
int iCols3 = 0;
double* pdblPadding = NULL;
int piPadding[2];
sciErr = getListItemAddress(_pvCtx, piAddrList, 2, &piAddr2);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblGrid);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
sciErr = getListItemAddress(_pvCtx, piAddrList, 3, &piAddr3);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
sciErr = getMatrixOfDouble(_pvCtx, piAddr3, &iRows3, &iCols3, &pdblPadding);
if (sciErr.iErr)
{
return SET_PROPERTY_ERROR;
}
piGrid[0] = (int)pdblGrid[0];
piGrid[1] = (int)pdblGrid[1];
piPadding[0] = (int)pdblPadding[0];
piPadding[1] = (int)pdblPadding[1];
setGraphicObjectProperty(iObjUID, __GO_GRID_OPT_GRID__, piGrid, jni_int_vector, 2);
setGraphicObjectProperty(iObjUID, __GO_GRID_OPT_PADDING__, piPadding, jni_int_vector, 2);
}
else if (strcmp(pstType, "OptGridBag") == 0)
{
return clearLayoutOptions(iObjUID);
}
else
{
freeAllocatedMatrixOfString(iRows, iCols, pstField);
return SET_PROPERTY_ERROR;
}
freeAllocatedMatrixOfString(iRows, iCols, pstField);
}
return SET_PROPERTY_SUCCEED;
}
/*--------------------------------------------------------------------------*/
int sci_TCL_SetVar(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrl2 = NULL;
char* l2 = NULL;
int* piAddrl1 = NULL;
int* piAddrStr = NULL;
char *VarName = NULL;
static int n1, m1;
static int n2, m2;
int paramoutINT = 0;
Tcl_Interp *TCLinterpreter = NULL;
CheckInputArgument(pvApiCtx, 2, 3);
CheckOutputArgument(pvApiCtx, 0, 1);
if (getTclInterp() == NULL)
{
releaseTclInterp();
Scierror(999, _("%s: Error main TCL interpreter not initialized.\n"), fname);
return 0;
}
releaseTclInterp();
if (nbInputArgument(pvApiCtx) == 3)
{
// three arguments given - get a pointer on the slave interpreter
if (checkInputArgumentType(pvApiCtx, 3, sci_strings))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 3.
if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 3);
return 1;
}
TCLinterpreter = Tcl_GetSlave(getTclInterp(), (l2));
freeAllocatedSingleString(l2);
if (TCLinterpreter == NULL)
{
releaseTclInterp();
Scierror(999, _("%s: No such slave interpreter.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 3);
return 0;
}
}
else
{
// only two arguments given - use the main interpreter
TCLinterpreter = getTclInterp();
}
if (checkInputArgumentType(pvApiCtx, 1, sci_strings) && checkInputArgumentType(pvApiCtx, 2, sci_strings))
{
char **Str = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrl1, &VarName))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrStr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m1, &n1, &Str))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
return 1;
}
// Efface valeur precedente
Tcl_UnsetVar(TCLinterpreter, VarName, TCL_GLOBAL_ONLY);
if ( (m1 == 1) && (n1 == 1) )
{
paramoutINT = SetVarAString(TCLinterpreter, VarName, Str);
}
else
{
paramoutINT = SetVarStrings(TCLinterpreter, VarName, Str, m1, n1);
}
freeAllocatedSingleString(VarName);
freeAllocatedMatrixOfString(m1, n1, Str);
}
else if (checkInputArgumentType(pvApiCtx, 1, sci_strings) && checkInputArgumentType(pvApiCtx, 2, sci_matrix))
{
#define COMPLEX 1
int *header = NULL;
int Cmplx;
double* l1 = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrl1, &VarName))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
freeAllocatedSingleString(VarName);
return 1;
}
if (isVarComplex(pvApiCtx, piAddrl1))
{
Scierror(999, _("This function doesn't work with Complex.\n"));
freeAllocatedSingleString(VarName);
releaseTclInterp();
return 0;
}
// Retrieve a matrix of double at position 2.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
freeAllocatedSingleString(VarName);
return 1;
}
if ( (m1 == 0) && (n1 == 0) )
{
Scierror(999, _("[] doesn't work with Tcl/Tk.\n"));
freeAllocatedSingleString(VarName);
releaseTclInterp();
return 0;
}
if ( (m1 == 1) && (n1 == 1) )
{
paramoutINT = SetVarScalar(TCLinterpreter, VarName, *l1);
}
else
{
paramoutINT = SetVarMatrix(TCLinterpreter, VarName, l1, m1, n1);
}
freeAllocatedSingleString(VarName);
}
else
{
if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname , 1);
}
if ((!checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix expected.\n"), fname , 2);
}
releaseTclInterp();
return 0;
}
if (createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, paramoutINT))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
releaseTclInterp();
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_uigetfont(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrfontNameAdr = NULL;
int* piAddrfontSizeAdr = NULL;
int* piAddrboldAdr = NULL;
int* boldAdr = NULL;
int* piAddritalicAdr = NULL;
int* italicAdr = NULL;
double* fontSizeAdr = NULL;
int fontChooserID = 0;
int nbRow = 0;
int nbCol = 0;
char **fontNameAdr = NULL;
int fontNameSize = 0;
char *selectedFontName = NULL;
int selectedFontSize = 0;
BOOL selectedBold = FALSE;
BOOL selectedItalic = FALSE;
CheckInputArgument(pvApiCtx, 0, 4);
CheckOutputArgument(pvApiCtx, 1, 4);
/* Default font name */
if (nbInputArgument(pvApiCtx) >= 1)
{
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfontNameAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrfontNameAdr, &nbRow, &nbCol, &fontNameAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
return 1;
}
fontNameSize = nbRow * nbCol;
if (fontNameSize != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return FALSE;
}
}
/* Default font size */
if (nbInputArgument(pvApiCtx) >= 2)
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrfontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 2.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrfontSizeAdr, &nbRow, &nbCol, &fontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 2);
return FALSE;
}
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 2);
return FALSE;
}
}
/* Is the default font bold ? */
if (nbInputArgument(pvApiCtx) >= 3)
{
if ((checkInputArgumentType(pvApiCtx, 3, sci_boolean)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrboldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 3.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddrboldAdr, &nbRow, &nbCol, &boldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
return FALSE;
}
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
return FALSE;
}
}
/* Is the default font italic ? */
if (nbInputArgument(pvApiCtx) >= 4)
{
if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddritalicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 4.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddritalicAdr, &nbRow, &nbCol, &italicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 4);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
}
/* Create the Java Object */
fontChooserID = createFontChooser();
/* Default font */
if (fontNameAdr != NULL)
{
setFontChooserFontName(fontChooserID, fontNameAdr[0]);
}
/* Default size */
if (fontSizeAdr != 0)
{
setFontChooserFontSize(fontChooserID, (int)fontSizeAdr[0]);
}
/* Default bold */
if (boldAdr != 0)
{
setFontChooserBold(fontChooserID, booltoBOOL(boldAdr[0]));
}
/* Default italic */
if (italicAdr != 0)
{
setFontChooserItalic(fontChooserID, booltoBOOL(italicAdr[0]));
}
/* Display it and wait for a user input */
fontChooserDisplayAndWait(fontChooserID);
/* Return the selected font */
/* Read the user answer */
selectedFontName = getFontChooserFontName(fontChooserID);
if (strcmp(selectedFontName, "")) /* The user selected a font */
{
selectedFontSize = getFontChooserFontSize(fontChooserID);
selectedBold = getFontChooserBold(fontChooserID);
selectedItalic = getFontChooserItalic(fontChooserID);
nbRow = 1;
nbCol = 1;
if (nbOutputArgument(pvApiCtx) >= 1)
{
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, (const char * const*) &selectedFontName);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (selectedFontName)
{
freeAllocatedSingleString(selectedFontName);
}
if (nbOutputArgument(pvApiCtx) >= 2)
{
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*fontSizeAdr = selectedFontSize;
}
if (nbOutputArgument(pvApiCtx) >= 3)
{
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*boldAdr = selectedBold;
}
if (nbOutputArgument(pvApiCtx) >= 4)
{
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*italicAdr = selectedItalic;
}
}
else /* The user canceled */
{
if (selectedFontName)
{
freeAllocatedSingleString(selectedFontName);
}
nbRow = 0;
nbCol = 0;
if (nbOutputArgument(pvApiCtx) >= 1)
{
/* Return "" as font name */
char* fontNameEmpty = NULL;
if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow * nbCol, (const char**) &fontNameEmpty))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (nbOutputArgument(pvApiCtx) >= 2)
{
/* Return [] as font size */
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (nbOutputArgument(pvApiCtx) >= 3)
{
/* Return [] as bold value */
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (nbOutputArgument(pvApiCtx) >= 4)
{
/* Return [] as italic value */
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
if (fontNameSize)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
}
ReturnArguments(pvApiCtx);
return TRUE;
}
int ScilabGateway::addToClasspath(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int * addr = 0;
int rows;
int cols;
char ** className = 0;
CheckInputArgumentAtLeast(pvApiCtx, 1);
CheckOutputArgument(pvApiCtx, 1, 1);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
for (int i = 1; i <= Rhs; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for argument #%d: string expected."), 1);
}
if (getAllocatedMatrixOfString(pvApiCtx, addr, &rows, &cols, &className))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
for (int j = 0; j < rows * cols; j++)
{
char * expandedPath = expandPathVariable(const_cast<char *>(className[j]));
if (expandedPath)
{
try
{
env.addtoclasspath(expandedPath);
}
catch (std::exception & /*e*/)
{
FREE(expandedPath);
freeAllocatedMatrixOfString(rows, cols, className);
throw;
}
FREE(expandedPath);
}
else
{
std::string str(className[j]);
freeAllocatedMatrixOfString(rows, cols, className);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot open the given file %s."), str.c_str());
}
}
freeAllocatedMatrixOfString(rows, cols, className);
className = 0;
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_uicontrol(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int nbRow = 0, nbCol = 0, k = 0;
int setStatus = SET_PROPERTY_SUCCEED;
int PARENT_NOT_FOUND = -2;
int NOT_FOUND = -1;
int inputIndex = 0, beginIndex = 0;
char *propertyName = NULL;
char *styleProperty = NULL;
int iPropertiesCount = sizeof(propertiesNames) / sizeof(char**);
unsigned long GraphicHandle = 0;
int found = 0; /* Does the property exists ? */
int *propertiesValuesIndices = NULL;
int iParentType = -1;
int *piParentType = &iParentType;
int iParentStyle = -1;
int *piParentStyle = &iParentStyle;
int iParentUID = 0;
int iUicontrol = 0;
int iCurrentFigure = 0;
CheckOutputArgument(pvApiCtx, 0, 1);
//init properties index
init_property_index();
if (nbInputArgument(pvApiCtx) == 0)
{
/* Create a pushbutton in current figure */
/* Create a new pushbutton */
GraphicHandle = getHandle(CreateUIControl(NULL));
/* Set current figure as parent */
iCurrentFigure = getCurrentFigure();
if (iCurrentFigure == 0)
{
iCurrentFigure = createNewFigureWithAxes();
}
iUicontrol = getObjectFromHandle(GraphicHandle);
setGraphicObjectRelationship(iCurrentFigure, iUicontrol);
}
else if (nbInputArgument(pvApiCtx) == 1)
{
/* Create a pushbutton in figure given as parameter */
/* Or give focus to the uicontrol given as parameter */
int* piAddr = NULL;
int iType = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isHandleType(pvApiCtx, piAddr) == FALSE && isStringType(pvApiCtx, piAddr) == FALSE)
{
OverLoad(1);
return FALSE;
}
#if 0 // Allow XML loading
else if (isStringType(pvApiCtx, piAddr))
{
char* pstXmlfile = NULL;
char* pstExpandedPath = NULL;
if (isScalar(pvApiCtx, piAddr) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return FALSE;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstXmlfile))
{
freeAllocatedSingleString(pstXmlfile);
Scierror(999, _("%s: No more memory.\n"), fname);
return FALSE;
}
pstExpandedPath = expandPathVariable(pstXmlfile);
freeAllocatedSingleString(pstXmlfile);
iUicontrol = xmlload(pstExpandedPath);
if (iUicontrol < 1)
{
Scierror(999, _("%s: can not read file %s.\n"), fname, pstExpandedPath);
FREE(pstExpandedPath);
return 0;
}
FREE(pstExpandedPath);
GraphicHandle = getHandle(iUicontrol);
/* Create return variable */
if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return TRUE;
}
#endif // Allow XML loading
else /* Get parent ID */
{
int* piAddr = NULL;
long long hParent = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isScalar(pvApiCtx, piAddr) == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return FALSE;
}
if (getScalarHandle(pvApiCtx, piAddr, &hParent))
{
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
iParentUID = getObjectFromHandle((long)hParent);
if (iParentUID != 0)
{
getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
if (iParentType == __GO_UICONTROL__) /* Focus management */
{
GraphicHandle = (unsigned long)hParent;
requestFocus(iParentUID);
}
else if (iParentType == __GO_FIGURE__ || iParentType == __GO_UIMENU__) /* PushButton creation */
{
/* Create a new pushbutton */
GraphicHandle = getHandle(CreateUIControl(NULL));
iUicontrol = getObjectFromHandle(GraphicHandle);
/* First parameter is the parent */
setGraphicObjectRelationship(iParentUID, iUicontrol);
setStatus = callSetProperty(pvApiCtx, iUicontrol, &hParent, sci_handles, 1, 1, (char*)propertiesNames[parent_property]);
if (setStatus == SET_PROPERTY_ERROR)
{
Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s', '%s' or '%s' handle expected.\n"), fname, 1, "Uicontrol",
"Figure", "Uimenu");
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s', '%s' or '%s' handle expected.\n"), fname, 1, "Uicontrol", "Figure",
"Uimenu");
return FALSE;
}
}
}
else
{
if (!checkInputArgumentType(pvApiCtx, 1, sci_handles) && !checkInputArgumentType(pvApiCtx, 1, sci_strings))
{
OverLoad(1);
return FALSE;
}
/* Allocate memory to store the position of properties in uicontrol call */
if ((propertiesValuesIndices = (int*)MALLOC(sizeof(int) * iPropertiesCount)) == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return FALSE;
}
/* Init all positions to NOT_FOUND */
for (inputIndex = 0; inputIndex < iPropertiesCount; inputIndex++)
{
propertiesValuesIndices[inputIndex] = NOT_FOUND; /* Property initialized as not found */
}
/**
* Odd number of input arguments
* First input is the parent ID
* All event inputs are property names
* All odd (except first) inputs are property values
*/
if (nbInputArgument(pvApiCtx) % 2 == 1)
{
if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
{
if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
{
int* piAddr = NULL;
double dblValue = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isScalar(pvApiCtx, piAddr) == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
return FALSE;
}
if (getScalarDouble(pvApiCtx, piAddr, &dblValue))
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
iParentUID = getFigureFromIndex((int)dblValue);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
"Frame uicontrol");
return FALSE;
}
}
else /* Get parent ID */
{
int* piAddr = NULL;
long long hParent = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isScalar(pvApiCtx, piAddr) == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
"Frame uicontrol");
return FALSE;
}
if (getScalarHandle(pvApiCtx, piAddr, &hParent))
{
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
iParentUID = getObjectFromHandle((long)hParent);
}
if (iParentUID == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
"Frame uicontrol");
return FALSE;
}
getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
if (iParentType != __GO_FIGURE__)
{
getGraphicObjectProperty(iParentUID, __GO_STYLE__, jni_int, (void **)&piParentStyle);
if (iParentType != __GO_UICONTROL__ ||
(iParentStyle != __GO_UI_FRAME__ && iParentStyle != __GO_UI_TAB__ && iParentStyle != __GO_UI_LAYER__))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
"Frame uicontrol");
return FALSE;
}
}
/* First parameter is the parent */
propertiesValuesIndices[parent_property] = 1;
// First input parameter which is a property name
beginIndex = 2;
}
/**
* Even number of input arguments
* All odd inputs are property names
* All even inputs are property values
*/
else
{
// First input parameter which is a property name
beginIndex = 1;
}
/* Get all properties positions */
for (inputIndex = beginIndex; inputIndex < Rhs; inputIndex = inputIndex + 2)
{
/* Read property name */
if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, inputIndex);
return FALSE;
}
else
{
int* piAddr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &propertyName))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, inputIndex);
return 1;
}
/* Bug 3031 */
/* We only want to compare propertyName along its length */
/* 'posi' must be matched to 'position' */
found = 0;
for (k = 0; k < iPropertiesCount ; k++)
{
if (strlen(propertyName) <= strlen(propertiesNames[k]))
{
if (strnicmp(propertyName, propertiesNames[k], strlen(propertyName)) == 0)
{
propertiesValuesIndices[k] = inputIndex + 1; /* Position of value for property */
found = 1;
break;
}
}
}
freeAllocatedSingleString(propertyName);
if (found == 0)
{
Scierror(999, _("%s: Unknown property: %s for '%s' handles.\n"), fname, propertyName, "Uicontrol");
return FALSE;
}
}
}
if (propertiesValuesIndices[style_property] != NOT_FOUND) /* Style found */
{
if ((checkInputArgumentType(pvApiCtx, propertiesValuesIndices[style_property], sci_strings)))
{
int* piAddr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[style_property], &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &styleProperty))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[style_property]);
return 1;
}
if (strcmp(styleProperty, "frame") == 0)
{
//check scrollable property to create a scroll frame instead of normal frame
if (propertiesValuesIndices[scrollable_property] != NOT_FOUND)
{
char* pstScroll = NULL;
int iScroll = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[scrollable_property], &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isStringType(pvApiCtx, piAddr) == 0 && isBooleanType(pvApiCtx, piAddr) == 0 && isScalar(pvApiCtx, piAddr) == 0)
{
Scierror(202, _("%s: Wrong type for argument #%d: string or boolean expected.\n"), fname, propertiesValuesIndices[scrollable_property]);
return 1;
}
if (isStringType(pvApiCtx, piAddr))
{
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstScroll))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[scrollable_property]);
return 1;
}
if (strcmp(pstScroll, "on") == 0)
{
iScroll = 1;
}
freeAllocatedSingleString(pstScroll);
}
else
{
if (getScalarBoolean(pvApiCtx, piAddr, &iScroll))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[scrollable_property]);
return 1;
}
}
if (iScroll)
{
freeAllocatedSingleString(styleProperty);
styleProperty = os_strdup("framescrollable");
}
propertiesValuesIndices[scrollable_property] = NOT_FOUND;
}
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, propertiesValuesIndices[style_property]);
return FALSE;
}
}
/* Create a new uicontrol */
iUicontrol = CreateUIControl(styleProperty);
freeAllocatedSingleString(styleProperty);
if (iUicontrol == 0) /* Error in creation */
{
Scierror(999, _("%s: Could not create 'Uicontrol' handle.\n"), fname);
return FALSE;
}
GraphicHandle = getHandle(iUicontrol);
/* If no parent given then the current figure is the parent */
if (propertiesValuesIndices[parent_property] == NOT_FOUND)
{
/* Set the parent */
iCurrentFigure = getCurrentFigure();
if (iCurrentFigure == 0)
{
iCurrentFigure = createNewFigureWithAxes();
}
propertiesValuesIndices[parent_property] = PARENT_NOT_FOUND;
}
/* Read and set all properties */
for (inputIndex = 1; inputIndex < iPropertiesCount; inputIndex++) /* Style has already been set */
{
if (propertiesValuesIndices[inputIndex] == PARENT_NOT_FOUND)
{
//special case for not specified parent
//but set relationship at the good moment.
setGraphicObjectRelationship(iCurrentFigure, iUicontrol);
}
else if (propertiesValuesIndices[inputIndex] != NOT_FOUND)
{
int* piAddr = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[inputIndex], &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (inputIndex == user_data_property || inputIndex == userdata_property) /* User data settings */
{
nbRow = -1;
nbCol = -1;
setStatus = callSetProperty(pvApiCtx, iUicontrol, piAddr, 0, 0, 0, (char*)propertiesNames[inputIndex]);
}
else /* All other properties */
{
/* Read property value */
switch (getInputArgumentType(pvApiCtx, propertiesValuesIndices[inputIndex]))
{
case sci_matrix:
{
double* pdblValue = NULL;
sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &nbRow, &nbCol, &pdblValue);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, propertiesValuesIndices[inputIndex]);
return 1;
}
setStatus = callSetProperty(pvApiCtx, iUicontrol, pdblValue, sci_matrix, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
break;
}
case sci_strings:
/* Index for String & TooltipString properties: Can be more than one character string */
if ((inputIndex == string_property) || (inputIndex == tooltipstring_property))
{
char** pstValue = NULL;
if (getAllocatedMatrixOfString(pvApiCtx, piAddr, &nbRow, &nbCol, &pstValue))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[inputIndex]);
return 1;
}
setStatus = callSetProperty(pvApiCtx, iUicontrol, pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
freeAllocatedMatrixOfString(nbRow, nbCol, pstValue);
}
else
{
char* pstValue = NULL;
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstValue))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, propertiesValuesIndices[inputIndex]);
return 1;
}
nbRow = (int)strlen(pstValue);
nbCol = 1;
setStatus = callSetProperty(pvApiCtx, iUicontrol, pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
freeAllocatedSingleString(pstValue);
}
break;
case sci_handles:
{
long long* pHandles = NULL;
sciErr = getMatrixOfHandle(pvApiCtx, piAddr, &nbRow, &nbCol, &pHandles);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, propertiesValuesIndices[inputIndex]);
return 1;
}
setStatus = callSetProperty(pvApiCtx, iUicontrol, pHandles, sci_handles, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
break;
}
case sci_tlist: //constraints and border
{
setStatus = callSetProperty(pvApiCtx, iUicontrol, piAddr, sci_tlist, 1, 1, (char*)propertiesNames[inputIndex]);
break;
}
default:
setStatus = SET_PROPERTY_ERROR;
break;
}
}
if (setStatus == SET_PROPERTY_ERROR)
{
Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char*)propertiesNames[inputIndex]);
return FALSE;
}
}
}
}
if (propertiesValuesIndices != NULL
&& (propertiesValuesIndices[sliderstep_property] == NOT_FOUND &&
(propertiesValuesIndices[min_property] != NOT_FOUND || propertiesValuesIndices[max_property] != NOT_FOUND))) /* SliderStep property not set */
{
/* Set SliderStep property to [1/100*(Max-Min) 1/10*(Max-Min)] */
double maxValue = 0;
double* pdblMaxValue = &maxValue;
double minValue = 0;
double* pdblMinValue = &minValue;
double pdblStep[2];
getGraphicObjectProperty(iUicontrol, __GO_UI_MIN__, jni_double, (void**) &pdblMinValue);
getGraphicObjectProperty(iUicontrol, __GO_UI_MAX__, jni_double, (void**) &pdblMaxValue);
pdblStep[0] = 0.01 * (maxValue - minValue);
pdblStep[1] = 0.1 * (maxValue - minValue);
setGraphicObjectProperty(iUicontrol, __GO_UI_SLIDERSTEP__, pdblStep, jni_double_vector, 2);
}
if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[position_property] == NOT_FOUND)) /* Position property not set */
{
double* pdblPosition = NULL;
getGraphicObjectProperty(iUicontrol, __GO_POSITION__, jni_double_vector, (void**) &pdblPosition);
setGraphicObjectProperty(iUicontrol, __GO_POSITION__, pdblPosition, jni_double_vector, 4);
releaseGraphicObjectProperty(__GO_POSITION__, pdblPosition, jni_double_vector, 4);
}
if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[visible_property] == NOT_FOUND)) /* Visible property not set */
{
/* Force the uicontrol to be visible because is invisible by default in the model (See bug #10346) */
int b = (int)TRUE;
setGraphicObjectProperty(iUicontrol, __GO_VISIBLE__, &b, jni_bool, 1);
}
FREE(propertiesValuesIndices);
/* Create return variable */
if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
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;
}