/*--------------------------------------------------------------------------*/
int sci_glue(char * fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrl1 = NULL;
long long* l1 = NULL;
double* l2 = NULL;
int* lind = NULL;
long long* outindex = NULL;
int numrow = 0, numcol = 0, n = 0, cx1 = 1;
int *pObj = NULL;
int i = 0;
int iCompoundUID = 0;
int iParentUID = 0;
int iCurrentParentUID = 0;
int* piCurrentParentUID = &iCurrentParentUID;
int iObjUID = 0;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
/* set or create a graphic window */
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &numrow, &numcol, &l1); /* We get the scalar value if it is ones */
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
n = numrow * numcol;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &l2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 2, numrow, numcol, &lind);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
if (n > 1)
{
C2F(dcopy)(&n, (double*)l1, &cx1, l2, &cx1);
C2F(dsort)(l2, &n, (int*)(lind));
for (i = 1; i < n; i++)
{
long long i1 = ((long long*)l2)[i];
long long i2 = ((long long*)l2)[i - 1];
if (i1 == i2)
{
Scierror(999, _("%s: Each handle should not appear twice.\n"), fname);
return 0;
}
}
}
/* we must change the pobj to the Compound type */
pObj = (int*)MALLOC(n * sizeof(int));
for (i = 0 ; i < n ; i++)
{
iObjUID = getObjectFromHandle((long)l1[i]);
pObj[i] = iObjUID;
if (iObjUID == 0)
{
FREE(pObj);
Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
return 0;
}
iCurrentParentUID = getParentObject(iObjUID);
//getGraphicObjectProperty(iObjUID, __GO_PARENT__, jni_string, (void **)&piCurrentParentUID);
if (i == 0)
{
iParentUID = iCurrentParentUID;
}
if (iParentUID != iCurrentParentUID)
{
FREE(pObj);
Scierror(999, _("%s: Objects must have the same parent.\n"), fname);
return 0;
}
}
//ret = CheckForCompound (handelsvalue, n);
//if (ret>0)
//{
// MEM LEAK
// Scierror(999,_("%s: Handle %d cannot be glued (invalid parent).\n"),fname,ret);
// return 0;
//}
//if (ret<0)
//{
// MEM LEAK
// Scierror(999,_("%s: Handle %d cannot be glued (invalid type).\n"),fname,-ret);
// return 0;
//}
iCompoundUID = createCompound(iParentUID, pObj, n);
setCurrentObject(iCompoundUID);
numrow = 1;
numcol = 1;
sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 3, numrow, numcol, &outindex);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
outindex[0] = getHandle(iCompoundUID);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 3;
ReturnArguments(pvApiCtx);
FREE(pObj);
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 sci_getcallbackobject(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrpObjUID = NULL;
int nbRow = 0;
int nbCol = 0;
char** pObjUID = NULL;
unsigned long graphicHandle = 0;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpObjUID);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrpObjUID, &nbRow, &nbCol, &pObjUID))
{
Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
return 1;
}
if (nbCol != 1 || nbRow == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return FALSE;
}
graphicHandle = getHandle(pObjUID[0]);
freeAllocatedMatrixOfString(nbRow, nbCol, pObjUID);
/* Create return variable */
if (graphicHandle == 0) /* Non-existing object --> return [] */
{
double* stkAdr = NULL;
nbRow = 0;
nbCol = 0;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
else /* Return the handle */
{
long long* stkAdr = NULL;
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;
ReturnArguments(pvApiCtx);
return TRUE;
}
