/*--------------------------------------------------------------------------*/
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_uimenu(char *fname, void *pvApiCtx)
{
SciErr sciErr;
int nbRow = 0, nbCol = 0;
int setStatus = SET_PROPERTY_SUCCEED;
int inputIndex = 0, beginIndex = 0;
char *propertyName = NULL;
int iParentUID = 0;
unsigned long GraphicHandle = 0;
int parentDefined = FALSE;
int iCurrentFigure = 0;
int iParentType = -1;
int *piParentType = &iParentType;
/* Create a new menu */
GraphicHandle = getHandle(CreateUimenu());
/* If no nbInputArgument(pvApiCtx) -> current figure is the parent (Ascendant compatibility) */
if (nbInputArgument(pvApiCtx) == 0)
{
// Set the parent property
iCurrentFigure = getCurrentFigure();
if (iCurrentFigure == 0)
{
iCurrentFigure = createNewFigureWithAxes();
}
setGraphicObjectRelationship(iCurrentFigure, getObjectFromHandle(GraphicHandle));
}
/**
* 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)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A graphic handle expected.\n"), fname, 1);
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;
}
// Retrieve a matrix of handle at position 1.
// YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
if (getScalarHandle(pvApiCtx, piAddr, &hParent))
{
Scierror(202, _("%s: Wrong type for input argument #%d: Handle expected.\n"), fname, 1);
return 1;
}
iParentUID = getObjectFromHandle((long)hParent);
if (iParentUID != 0)
{
getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
if (iParentType != __GO_FIGURE__ && iParentType != __GO_UIMENU__)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or '%s' handle expected.\n"), fname, 1, "Figure", "Uimenu");
return FALSE;
}
// Set the parent property
callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), &hParent, sci_handles, 1, 1, "parent");
// Set the flag to avoid setting the parent two times
parentDefined = TRUE;
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or '%s' handle expected.\n"), fname, 1, "Figure", "Uimenu");
return FALSE;
}
// 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;
}
/* Read and set all properties */
for (inputIndex = beginIndex; inputIndex < nbInputArgument(pvApiCtx); inputIndex = inputIndex + 2)
{
int* piAddrValue = NULL;
int* piAddrProperty = NULL;
int isUserDataProperty = 0;
int iPropertyValuePositionIndex = inputIndex + 1;
size_t posStackOrAdr = 0;
/* 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
{
sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddrProperty);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddrProperty, &propertyName))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, inputIndex);
return 1;
}
if (stricmp(propertyName, "parent") == 0)
{
parentDefined = TRUE;
}
isUserDataProperty = (stricmp(propertyName, "user_data") == 0) || (stricmp(propertyName, "userdata") == 0);
}
sciErr = getVarAddressFromPosition(pvApiCtx, iPropertyValuePositionIndex, &piAddrValue);
if (sciErr.iErr)
{
printError(&sciErr, 0);
freeAllocatedSingleString(propertyName);
return 1;
}
if (isUserDataProperty)
{
nbRow = -1;
nbCol = -1;
setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), piAddrValue, 0, 0, 0, propertyName);
}
else
{
/* Read property value */
switch (getInputArgumentType(pvApiCtx, iPropertyValuePositionIndex))
{
case sci_matrix:
{
double* pdblValue = NULL;
sciErr = getMatrixOfDouble(pvApiCtx, piAddrValue, &nbRow, &nbCol, &pdblValue);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, iPropertyValuePositionIndex);
freeAllocatedSingleString(propertyName);
return 1;
}
setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), pdblValue, sci_matrix, nbRow, nbCol, propertyName);
break;
}
case sci_strings:
{
char* pstValue = NULL;
if (getAllocatedSingleString(pvApiCtx, piAddrValue, &pstValue))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, iPropertyValuePositionIndex);
freeAllocatedSingleString(propertyName);
return 1;
}
nbRow = (int)strlen(pstValue);
nbCol = 1;
setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, propertyName);
freeAllocatedSingleString(pstValue);
break;
}
case sci_handles:
{
long long* phValues = NULL;
sciErr = getMatrixOfHandle(pvApiCtx, piAddrValue, &nbRow, &nbCol, &phValues);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, iPropertyValuePositionIndex);
freeAllocatedSingleString(propertyName);
return 1;
}
setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), phValues, sci_handles, nbRow, nbCol, propertyName);
break;
}
case sci_list:
{
getListItemNumber(pvApiCtx, piAddrValue, &nbRow);
nbCol = 1;
setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), piAddrValue, sci_list, nbRow, nbCol, propertyName);
break;
}
default:
{
setStatus = SET_PROPERTY_ERROR;
break;
}
}
}
if (setStatus == SET_PROPERTY_ERROR)
{
Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
freeAllocatedSingleString(propertyName);
return FALSE;
}
freeAllocatedSingleString(propertyName);
}
/* If the parent is not given, the current figure is set as parent */
if (!parentDefined && (nbInputArgument(pvApiCtx) != 0))
{
// Set the parent property
iCurrentFigure = getCurrentFigure();
if (iCurrentFigure == 0)
{
iCurrentFigure = createNewFigureWithAxes();
}
setGraphicObjectRelationship(iCurrentFigure, getObjectFromHandle(GraphicHandle));
}
/* Create return variable */
nbRow = 1;
nbCol = 1;
// YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
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_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;
}
/*--------------------------------------------------------------------------
* 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;
}
/*--------------------------------------------------------------------------
* 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;
}