/*--------------------------------------------------------------------------*/ static int getScalarFromStack(int paramIndex, char * funcName, double* res, void* pvApiCtx) { SciErr sciErr; int m = 0; int n = 0; int* piAddrstackPointer = NULL; double* stackPointer = NULL; if ((!checkInputArgumentType(pvApiCtx, paramIndex, sci_matrix))) { Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), funcName, paramIndex); return -1; } /* get the handle */ sciErr = getVarAddressFromPosition(pvApiCtx, paramIndex, &piAddrstackPointer); if (sciErr.iErr) { printError(&sciErr, 0); return -1; } // Retrieve a matrix of double at position paramIndex. sciErr = getMatrixOfDouble(pvApiCtx, piAddrstackPointer, &m, &n, &stackPointer); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), funcName, paramIndex); return -1; } if (m * n != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Real scalar expected.\n"), funcName, paramIndex); return -1; } *res = *stackPointer; return 0; }
/*--------------------------------------------------------------------------*/ 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; }
/*--------------------------------------------------------------------------*/ 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_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 sci_TCL_UnsetVar(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrl1 = NULL; int* piAddrl2 = NULL; char* l2 = NULL; static int n1, m1; static int n2, m2; Tcl_Interp *TCLinterpreter = NULL; CheckInputArgument(pvApiCtx, 1, 2); CheckOutputArgument(pvApiCtx, 1, 1); if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { int paramoutINT = 0; char *VarName = 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; } if (!existsGlobalInterp()) { freeAllocatedSingleString(VarName); Scierror(999, _("%s: Error main TCL interpreter not initialized.\n"), fname); return 0; } if (nbInputArgument(pvApiCtx) == 2) { // two arguments given - get a pointer on the slave interpreter if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2); if (sciErr.iErr) { freeAllocatedSingleString(VarName); printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2)) { freeAllocatedSingleString(VarName); Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2); return 1; } TCLinterpreter = Tcl_GetSlave(getTclInterp(), (l2)); freeAllocatedSingleString(l2); releaseTclInterp(); if (TCLinterpreter == NULL) { freeAllocatedSingleString(VarName); Scierror(999, _("%s: No such slave interpreter.\n"), fname); return 0; } } else { freeAllocatedSingleString(VarName); Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 2); return 0; } } else { // only one argument given - use the main interpreter TCLinterpreter = getTclInterp(); } paramoutINT = (int)(Tcl_UnsetVar(TCLinterpreter, VarName, TCL_GLOBAL_ONLY) != TCL_ERROR); freeAllocatedSingleString(VarName); if (createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, paramoutINT)) { Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); } else { releaseTclInterp(); Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1); return 0; } releaseTclInterp(); return 0; }
/*--------------------------------------------------------------------------*/ int sci_rotate_axes(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrstackPointer = NULL; long long* stackPointer = NULL; int nbRow = 0; int nbCol = 0; int iUID = 0; int* piUID = &iUID; int iType = -1; int *piType = &iType; /* check size of input and output */ CheckInputArgument(pvApiCtx, 0, 1); CheckOutputArgument(pvApiCtx, 0, 1); if (nbInputArgument(pvApiCtx) == 0) { iUID = getCurrentFigure(); } else { /* Get figure or subwin handle */ if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles))) { Scierror(999, _("%s: Wrong type for input argument #%d: Single Figure or Axes handle expected.\n"), fname, 1); return -1; } 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, &nbRow, &nbCol, &stackPointer); 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 type for input argument #%d: Single Figure or Axes handle expected.\n"), fname, 1); return -1; } iUID = getObjectFromHandle((long int) * stackPointer); getGraphicObjectProperty(iUID, __GO_TYPE__, jni_int, (void **)&piType); if (iType == __GO_AXES__) { iUID = getParentObject(iUID); } } if (iUID == 0) { Scierror(999, _("%s: The handle is not or no more valid.\n"), fname); return -1; } setGraphicObjectProperty(iUID, __GO_INFO_MESSAGE__, "Right click and drag to rotate.", jni_string, 1); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); 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; }
/*--------------------------------------------------------------------------*/ static int xlfont_one_rhs(char * fname) { SciErr sciErr; if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { int* piAddrl1 = NULL; int* l1 = NULL; char* strl1 = NULL; int m1 = 0, n1 = 0; 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, &strl1)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1); return 1; } if (strcmp(strl1, "AVAILABLE_FONTS") == 0) { int nbElements = 0; char **fontsname = getAvailableFontsName(&nbElements); m1 = nbElements; n1 = 1; sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, (const char * const*)fontsname); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } freeArrayOfString(fontsname, nbElements); freeAllocatedSingleString(strl1); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; } else if (strcmp(strl1, "reset") == 0) { resetFontManager(); freeAllocatedSingleString(strl1); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } else { if (isAvailableFontsName(strl1)) { int fontID = addFont(strl1); m1 = 1; n1 = 1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } l1[0] = fontID; freeAllocatedSingleString(strl1); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; } else if (FileExist(strl1)) { int fontID = addFontFromFilename(strl1); m1 = 1; n1 = 1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } l1[0] = fontID; freeAllocatedSingleString(strl1); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; } else { Scierror(999, _("%s: Wrong value for input argument #%d: A valid fontname expected.\n"), fname, 1); } } freeAllocatedSingleString(strl1); } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1); return 0; } return 0; }
/*--------------------------------------------------------------------------*/ int sci_getcallbackobject(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrpObjUID = NULL; int nbRow = 0; int nbCol = 0; double ObjUID = 0; unsigned long graphicHandle = 0; CheckInputArgument(pvApiCtx, 1, 1); CheckOutputArgument(pvApiCtx, 0, 1); if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpObjUID); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getScalarDouble(pvApiCtx, piAddrpObjUID, &ObjUID)) { Scierror(202, _("%s: Wrong type for argument #%d: Real expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1); return FALSE; } graphicHandle = getHandle((int)ObjUID); /* Create return variable */ if (graphicHandle == 0) /* Non-existing object --> return [] */ { if (createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1)) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else /* Return the handle */ { if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, graphicHandle)) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_qp_solve(char *fname, unsigned long fname_len) { SciErr sciErr; static int un = 1, deux = 2; // n : first dimension of Q // nbis : second dimension of Q (nbis is expected to be equal to n) static int n = 0, nbis = 0; static int unbis = 0; static int m = 0, next = 0; static int mbis = 0; static int pipo = 0; static int nact = 0; int r = 0; static int lw = 0, k = 0; static SciSparse Sp; static int issparse = 0; double *work = NULL; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int* piAddr4 = NULL; int* piAddr5 = NULL; double* Q = NULL; double* C = NULL; double* p = NULL; double* b = NULL; int* me = NULL; double* x = NULL; int* iact = NULL; int* iter = NULL; double* crval = NULL; int *ierr = NULL; /* Check rhs and lhs */ CheckInputArgument(pvApiCtx, 5, 5) ; CheckOutputArgument(pvApiCtx, 1, 5) ; /*Warning this interface does not support arguments passed by reference */ /* RhsVar: qp_solve(Q,p,C,b,me) */ /* 1,2,3,4,5 */ next = nbInputArgument(pvApiCtx) + 1; /* Variable 1 (Q) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &n, &nbis, &Q); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); printError(&sciErr, 0); return 1; } //CheckSquare if (n != nbis) { Scierror(999, _("%s: Wrong size for input argument #%d: A square matrix expected.\n"), fname, 1); return 1; } /* Variable 2 (p) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &nbis, &unbis, &p); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2); printError(&sciErr, 0); return 1; } //CheckLength if (nbis * unbis != n) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 2, nbis * unbis); return 1; } /* Variable 3 (C) */ issparse = (checkInputArgumentType(pvApiCtx, 3, 5)); //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (!issparse) { // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &nbis, &m, &C); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } } else { if (isVarComplex(pvApiCtx, piAddr3)) { Sp.it = 1; sciErr = getComplexSparseMatrix(pvApiCtx, piAddr3, &(Sp.m), &(Sp.n), &(Sp.nel), &(Sp.mnel), &(Sp.icol), &(Sp.R), &(Sp.I)); } else { Sp.it = 0; sciErr = getSparseMatrix(pvApiCtx, piAddr3, &(Sp.m), &(Sp.n), &(Sp.nel), &(Sp.mnel), &(Sp.icol), &(Sp.R)); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } nbis = Sp.m; m = Sp.n; } if ( nbis != n ) // car C est passee en transposee dans la macro qpsolve { Scierror(999, _("%s: Wrong size for input argument #%d: %d column(s) expected for matrix %s.\n"), fname, 3, n, "C"); return 0; } /* Variable 4 (b) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &mbis, &unbis, &b); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4); printError(&sciErr, 0); return 1; } //CheckLength if (mbis * unbis != m) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 4, mbis * unbis); return 1; } /* Variable 5 (me) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 5. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr5, &pipo, &unbis, &me); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 5); printError(&sciErr, 0); return 1; } //CheckScalar if (pipo != 1 || unbis != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 5); return 1; } if ((*(me) < 0) || (*(me) > n)) { Scierror(999, _("%s: Wrong value for input argument #%d: %s must be an integer in the range 0 to %d.\n"), fname, 5, "me", n); return 0; } /* nbOutputArgument(pvApiCtx) variables: x, iact, iter, crval */ next = Rhs; sciErr = allocMatrixOfDouble(pvApiCtx, next + 1, n, un, &x); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 2, m, un, &iact); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 3, deux, un, &iter); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, next + 4, un, un, &crval); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 5, un, un, &ierr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } r = Min(n, m); lw = 2 * n + r * (r + 5) / 2 + 2 * m + 1; if ((work = (double *)MALLOC(lw * sizeof(double))) == NULL) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 1; } /* change the sign of C and b.*/ *ierr = 0; if (!issparse) { /* linear constraints matrix is stored full */ C2F(qpgen2)((Q), (p), &n, &n, (x), (crval), (C), (b), &n, &m, (me), (iact), &nact, (iter), work, (ierr)); } else { /* linear constraints matrix is a sparse matrix */ /* Change the linear constraints matrix representation: qpgen1sci requires column-compressed sparse matrix internal representation while Scilab sparse matrices are row-compressed */ double *R = NULL, *I = NULL; int *ind = NULL; if ((R = (double *)MALLOC(Sp.nel * sizeof(double))) == NULL) { FREE(work); work = NULL; Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 1; } if ((ind = (int *)MALLOC((m + Sp.nel) * sizeof(int))) == NULL) { FREE(work); work = NULL; FREE(R); R = NULL; Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 1; } // Transpose the sparse matrix A C2F(spt)(&n, &m, &(Sp.nel) , &(Sp.it), (int *)work, Sp.R, Sp.I, Sp.mnel, Sp.icol, R, I, ind, ind + m); C2F(qpgen1sci)((Q), (p), &n, &n, (x), (crval), ind, ind + m, R, (b), &m, (me), (iact), &nact, (iter), work, (ierr)); FREE(work); work = NULL; FREE(R); R = NULL; FREE(ind); ind = NULL; } for (k = nact; k < m; k++) { (iact)[k] = 0; } /* LhsVar: [x, iact, iter, f] = qp_solve(...) */ if (Lhs != 5) { if (*ierr == 0) { for (k = 0; k < Lhs; k++) { AssignOutputVariable(pvApiCtx, 1 + k) = next + 1 + k; } ReturnArguments(pvApiCtx); } else if (*ierr == 1) { Scierror(999, _("%s: The minimization problem has no solution.\n"), fname); } else if (*ierr == 2) { Scierror(999, _("%s: Q is not symmetric positive definite.\n"), fname); } } else { for (k = 0; k < Lhs; k++) { AssignOutputVariable(pvApiCtx, 1 + k) = next + 1 + k; } if (*ierr == 1) { if (getWarningMode()) { sciprint(_("\n%s: Warning: The minimization problem has no solution. The results may be inaccurate.\n\n"), fname); } } else if (*ierr == 2) { if (getWarningMode()) { sciprint(_("\n%s: Warning: Q is not symmetric positive definite. The results may be inaccurate.\n\n"), fname); } } ReturnArguments(pvApiCtx); } 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 sci_TCL_DeleteInterp(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrl2 = NULL; char* l2 = NULL; CheckInputArgument(pvApiCtx, 0, 1); CheckOutputArgument(pvApiCtx, 1, 1); if (nbInputArgument(pvApiCtx) == 1) { if (!existsGlobalInterp()) { Scierror(999, _("%s: Error main TCL interpreter not initialized.\n"), fname); return 0; } if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { static int n2, m2; Tcl_Interp *TCLinterpreter = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1); return 1; } TCLinterpreter = Tcl_GetSlave(getTclInterp(), (l2)); freeAllocatedSingleString(l2); releaseTclInterp(); if (TCLinterpreter == NULL) { Scierror(999, _("%s: No such slave interpreter.\n"), fname); return 0; } else { Tcl_DeleteInterp(TCLinterpreter); TCLinterpreter = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1); return 0; } } else // nbInputArgument(pvApiCtx) == 0 { releaseTclInterp(); CloseTCLsci(); InitializeTclTk(); } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_x_mdialog(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrlabelsAdr = NULL; int* piAddrlineLabelsAdr = NULL; int* piAddrdefaultValuesAdr = NULL; int* piAddrcolumnLabelsAdr = NULL; double* emptyMatrixAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowDefaultValues = 0, nbColDefaultValues = 0; int nbRowLineLabels = 0, nbColLineLabels = 0; int nbRowColumnLabels = 0, nbColColumnLabels = 0; int messageBoxID = 0; char **labelsAdr = NULL; char **lineLabelsAdr = NULL; char **columnLabelsAdr = NULL; char **defaultValuesAdr = NULL; int userValueSize = 0; char **userValue = NULL; CheckInputArgument(pvApiCtx, 3, 4); CheckOutputArgument(pvApiCtx, 0, 1); /* READ THE LABELS */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Multiple Values Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr); /* READ THE LINE LABELS */ if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlineLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if (nbRowLineLabels != 1 && nbColLineLabels != 1) { freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels); freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } /* READ THE COLUMN LABELS or DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 3, sci_strings)) { if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if ((nbRowDefaultValues != nbRowLineLabels) || (nbColDefaultValues != nbColLineLabels)) { freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr); Scierror(999, _("%s: Wrong size for input argument #%d: It must have same dimensions as argument #%d.\n"), fname, 3, 2); return FALSE; } setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr); } else { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrcolumnLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrcolumnLabelsAdr, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if (nbRowColumnLabels != 1 && nbColColumnLabels != 1) { freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } setMessageBoxColumnLabels(messageBoxID, columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels); freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr); } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } if (nbInputArgument(pvApiCtx) == 4) { /* READ DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 4, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 4. // DO NOT FORGET TO RELEASE MEMORY via freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr). if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4); return 1; } if ((nbRowDefaultValues != nbRowLineLabels * nbColLineLabels) || (nbColDefaultValues != nbRowColumnLabels * nbColColumnLabels)) { Scierror(999, _("%s: Wrong size for input argument #%d: %d x %d matrix of strings expected.\n"), fname, 4, nbRowLineLabels * nbColLineLabels, nbRowColumnLabels * nbColColumnLabels); freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); return FALSE; } setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 4); return FALSE; } } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0; nbCol = 0; // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int emptyMatrixAdr". sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else { userValue = getMessageBoxValue(messageBoxID); nbCol = 1; nbRowDefaultValues = nbColLineLabels * nbRowLineLabels; nbColDefaultValues = 1; if (nbInputArgument(pvApiCtx) == 4) { nbColDefaultValues = nbColColumnLabels * nbRowColumnLabels; } createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValue); delete[] userValue; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_xgetmouse(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; double* l2 = NULL; int m1 = 1, n1 = 3; int mouseButtonNumber = 0; int windowsID = 0; int sel[2], m = 0, n = 0; int pixelCoords[2]; double userCoords2D[2] = {0.0, 0.0}; int selPosition = 0; CheckInputArgument(pvApiCtx, 0, 1); CheckOutputArgument(pvApiCtx, 1, 2); switch (nbInputArgument(pvApiCtx)) { case 1: if (checkInputArgumentType(pvApiCtx, 1, sci_boolean)) { selPosition = 1; } else { Scierror(999, _("%s: Wrong type for input argument #%d: Boolean vector expected.\n"), fname, 1); return FALSE; } break; default: // Call Java xgetmouse // No need to set any option. break; } // Select current figure or create it getOrCreateDefaultSubwin(); // Call Java to get mouse information if (selPosition != 0) { int* l1Sel = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, selPosition, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of boolean at position selPosition. sciErr = getMatrixOfBoolean(pvApiCtx, piAddrl1, &m, &n, &l1Sel); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, selPosition); return 1; } //CheckDims if (m * n != 2 || 1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, selPosition, 2, 1); return 1; } sel[0] = (int)l1Sel[0]; sel[1] = (int)l1Sel[1]; // Call Java xgetmouse CallJxgetmouseWithOptions(sel[0], sel[1]); } else { CallJxgetmouse(); } // Get return values mouseButtonNumber = getJxgetmouseMouseButtonNumber(); pixelCoords[0] = (int) getJxgetmouseXCoordinate(); pixelCoords[1] = (int) getJxgetmouseYCoordinate(); sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } // No need to calculate coordinates if callback or close is trapped if (mouseButtonNumber == -1000 || mouseButtonNumber == -2) { l1[0] = -1; l1[1] = -1; l1[2] = (double) mouseButtonNumber; } else { // Convert pixel coordinates to user coordinates int iClickedSubwinUID = getCurrentSubWin(); updateSubwinScale(iClickedSubwinUID); sciGet2dViewCoordFromPixel(iClickedSubwinUID, pixelCoords, userCoords2D); l1[0] = userCoords2D[0]; l1[1] = userCoords2D[1]; l1[2] = (double) mouseButtonNumber; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; switch (Lhs) { case 1: ReturnArguments(pvApiCtx); return 0; case 2: sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m1, m1, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } l2[0] = windowsID; /* this is the window number */ AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; ReturnArguments(pvApiCtx); return 0; } ReturnArguments(pvApiCtx); return -1; }
/*--------------------------------------------------------------------------*/ int sci_exportUI(char * fname, unsigned long fname_len) { SciErr sciErr; int* piAddrstackPointer = NULL; int iFigureId = 0; // id of the figure to export int *piFigureId = &iFigureId; int iRows = 0; int iCols = 0; int iHandleType = -1; int *piHandleType = &iHandleType; CheckOutputArgument(pvApiCtx, 0, 1); CheckInputArgument(pvApiCtx, 1, 1); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (checkInputArgumentType(pvApiCtx, 1, sci_handles)) // exportUI(figHandle) { char *pstFigureUID = NULL; char *pstHandleType = NULL; long long* stackPointer = NULL; // Retrieve a matrix of handle at position 1. sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &iRows, &iCols, &stackPointer); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1); return 1; } if (iRows * iCols != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A Real Scalar or a 'Figure' handle expected.\n"), fname, 1); } pstFigureUID = getObjectFromHandle((unsigned long) * stackPointer); getGraphicObjectProperty(pstFigureUID, __GO_TYPE__, jni_int, (void **)&piHandleType); if (iHandleType == __GO_FIGURE__) { Scierror(999, _("%s: Wrong type for input argument #%d: A Real Scalar or a 'Figure' handle expected.\n"), fname, 1); return FALSE; } getGraphicObjectProperty(pstFigureUID, __GO_ID__, jni_int, (void **)&piFigureId); } else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) // exportUI(figId) { double* stackPointer = NULL; // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrstackPointer, &iRows, &iCols, &stackPointer); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); return 1; } if (iRows * iCols != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A Real Scalar or a 'Figure' handle expected.\n"), fname, 1); return FALSE; } iFigureId = (int) * stackPointer; } else { Scierror(999, _("%s: Wrong type for input argument #%d: A Real Scalar or a 'Figure' handle expected.\n"), fname, 1); return FALSE; } // call the export function exportUserInterface(iFigureId); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ static int xlfont_n_rhs(char * fname) { SciErr sciErr; BOOL isBold = FALSE; BOOL isItalic = FALSE; if (nbInputArgument(pvApiCtx) == 3) { int m3 = 0, n3 = 0; int* piAddrl3 = NULL; int* l3 = NULL; if ((!checkInputArgumentType(pvApiCtx, 3, sci_boolean))) { Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of boolean at position 3. sciErr = getMatrixOfBoolean(pvApiCtx, piAddrl3, &m3, &n3, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 3); return 1; } isBold = (BOOL) * l3; } if (nbInputArgument(pvApiCtx) == 4) { int m4 = 0, n4 = 0; int* piAddrl4 = NULL; int* l4 = NULL; if ((!checkInputArgumentType(pvApiCtx, 4, sci_boolean))) { Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrl4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of boolean at position 4. sciErr = getMatrixOfBoolean(pvApiCtx, piAddrl4, &m4, &n4, &l4); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 4); return 1; } isItalic = (BOOL) * l4; } if (((checkInputArgumentType(pvApiCtx, 1, sci_strings))) && ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))) { int m1 = 0, n1 = 0; int m2 = 0, n2 = 0; char* strl1 = NULL; double* l2 = NULL; int* l1 = NULL; int* piAddrl1 = NULL; int* piAddrl2 = 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, &strl1)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. 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; } if ((m2 == 1) && (n2 == 1)) { int fontIndex = (int)l2[0]; char *fontname = strl1; if (fontIndex < 0) { Scierror(999, _("%s: Wrong value for input argument #%d: Non-negative int expected.\n"), fname, 2); return 0; } if ((nbInputArgument(pvApiCtx) == 2) && FileExist(fontname)) { int Id = changeFontFromFilename(fontIndex, fontname); m1 = 1; n1 = 1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } l1[0] = Id; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); } else if (isAvailableFontsName(fontname)) { int Id = changeFontWithProperty(fontIndex, fontname, isBold, isItalic); m1 = 1; n1 = 1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } l1[0] = Id; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); } else { Scierror(999, _("%s: Wrong value for input argument #%d: A valid fontname expected.\n"), fname, 1); } } else { Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 2); } freeAllocatedSingleString(strl1); } else { if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings))) { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1); return 0; } if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix))) { Scierror(999, _("%s: Wrong type for input argument #%d: Non-negative int expected.\n"), fname, 2); return 0; } } return 0; }
/*--------------------------------------------------------------------------*/ int sci_unsetmenu(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrmenuNameAdr = NULL; char* menuNameAdr = NULL; int* piAddrfigureNumberAdr = NULL; double* figureNumberAdr = NULL; int* piAddrsubMenuIndexAdr = NULL; double* subMenuIndexAdr = NULL; int nbRow = 0; int nbCol = 0; // Check parameter number CheckInputArgument(pvApiCtx, 1, 3); CheckOutputArgument(pvApiCtx, 1, 1); if (nbInputArgument(pvApiCtx) == 1) { // Error message in not in standard mode (we need figure number) if (getScilabMode() != SCILAB_STD) { Scierror(999, _("%s: Figure number must be given when not in '%s' mode.\n"), fname, "STD"); return FALSE; } // Unset a Menu of Scilab Main Window if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings))) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1); return FALSE; } sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } EnableMenu(getConsoleIdentifier(), menuNameAdr, FALSE); freeAllocatedSingleString(menuNameAdr); } else if (nbInputArgument(pvApiCtx) == 2) { // Unset a Menu a Scilab Graphic Window if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for 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; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } EnableMenu(getFigureFromIndex((int)*figureNumberAdr), menuNameAdr, FALSE); freeAllocatedSingleString(menuNameAdr); } else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)) && (checkInputArgumentType(pvApiCtx, 2, sci_matrix))) // Unset a submenu in main window { // Error message in not in standard mode (we need figure number) if (getScilabMode() != SCILAB_STD) { Scierror(999, _("%s: Figure number must be given when not in '%s' mode.\n"), fname, "STD"); return FALSE; } sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrsubMenuIndexAdr); if (sciErr.iErr) { printError(&sciErr, 0); freeAllocatedSingleString(menuNameAdr); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2); freeAllocatedSingleString(menuNameAdr); return 1; } if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 2); freeAllocatedSingleString(menuNameAdr); return FALSE; } EnableSubMenu(getConsoleIdentifier(), menuNameAdr, (int)*subMenuIndexAdr, FALSE); freeAllocatedSingleString(menuNameAdr); } else { Scierror(999, _("%s: Wrong input arguments: '%s' or '%s' expected.\n"), fname, "(button, nsub)", "(gwin, button)"); return FALSE; } } else // Unset a submenu in graphics window { if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for 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; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 1); return FALSE; } if ((checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return FALSE; } if ((checkInputArgumentType(pvApiCtx, 3, sci_matrix))) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrsubMenuIndexAdr); if (sciErr.iErr) { printError(&sciErr, 0); freeAllocatedSingleString(menuNameAdr); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); freeAllocatedSingleString(menuNameAdr); return 1; } if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 3); freeAllocatedSingleString(menuNameAdr); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 3); freeAllocatedSingleString(menuNameAdr); return FALSE; } EnableSubMenu(getFigureFromIndex((int)*figureNumberAdr), menuNameAdr, (int)*subMenuIndexAdr, FALSE); freeAllocatedSingleString(menuNameAdr); } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); 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_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 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_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; }
/*--------------------------------------------------------------------------*/ 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_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_uigetcolor(char *fname, void* pvApiCtx) { SciErr sciErr; //WARNING ALL NEW DECALRATIONS ARE HERE IF YOUR HAVE MANY FUNCTIONS //IN THE FILE YOU HAVE PROBABLY TO MOVE DECLARATIONS IN GOOD FUNCTIONS int* piAddrredAdr = NULL; double* redAdr = NULL; int* piAddrtitleAdr = NULL; char* titleAdr = NULL; int* piAddrgreenAdr = NULL; double* greenAdr = NULL; int* piAddrblueAdr = NULL; double* blueAdr = NULL; int colorChooserID = 0; int firstColorIndex = 0; int nbRow = 0, nbCol = 0; double *selectedRGB = NULL; CheckInputArgument(pvApiCtx, 0, 4); if ((nbOutputArgument(pvApiCtx) != 1) && (nbOutputArgument(pvApiCtx) != 3)) /* Bad use */ { Scierror(999, _("%s: Wrong number of output arguments: %d or %d expected.\n"), fname, 1, 3); return FALSE; } /* Rhs==1: title or [R, G, B] given */ if (nbInputArgument(pvApiCtx) == 1) { if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrredAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } if ((nbRow != 1) || (nbCol != 3)) { Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 1, 3); return FALSE; } } else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1); return FALSE; } } /* Title and [R, G, B] given */ if (nbInputArgument(pvApiCtx) == 2) { /* Title */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1); return FALSE; } /* [R, G, B] */ if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrredAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr); 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 != 3) { Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3); return FALSE; } } /* No title given but colors given with separate values */ if (nbInputArgument(pvApiCtx) == 3) { firstColorIndex = 1; } /* Title and colors given with separate values */ if (nbInputArgument(pvApiCtx) == 4) { firstColorIndex = 2; /* Title */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1); return FALSE; } } /* R, G, B given */ if (nbInputArgument(pvApiCtx) >= 3) { /* Default red value */ if ((checkInputArgumentType(pvApiCtx, firstColorIndex, sci_matrix))) { sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex, &piAddrredAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position firstColorIndex. sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex); return 1; } if (nbRow*nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex); return FALSE; } /* Default green value */ if (checkInputArgumentType(pvApiCtx, firstColorIndex + 1, sci_matrix)) { sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 1, &piAddrgreenAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position firstColorIndex + 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrgreenAdr, &nbRow, &nbCol, &greenAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex + 1); return 1; } if (nbRow*nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1); return FALSE; } /* Default blue value */ if (checkInputArgumentType(pvApiCtx, firstColorIndex + 2, sci_matrix)) { sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 2, &piAddrblueAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position firstColorIndex + 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddrblueAdr, &nbRow, &nbCol, &blueAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex + 2); return 1; } if (nbRow*nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2); return FALSE; } } /* Create the Java Object */ colorChooserID = createColorChooser(); /* Title */ if (titleAdr != 0) { setColorChooserTitle(colorChooserID, titleAdr); freeAllocatedSingleString(titleAdr); } /* Default red value */ if (redAdr != 0) { if (greenAdr != 0 ) /* All values given in first input argument */ { setColorChooserDefaultRGBSeparateValues(colorChooserID, (int)redAdr[0], (int)greenAdr[0], (int)blueAdr[0]); } else { setColorChooserDefaultRGB(colorChooserID, redAdr); } } /* Display it and wait for a user input */ colorChooserDisplayAndWait(colorChooserID); /* Return the selected color */ /* Read the user answer */ selectedRGB = getColorChooserSelectedRGB(colorChooserID); if (selectedRGB[0] >= 0) /* The user selected a color */ { nbRow = 1; if (nbOutputArgument(pvApiCtx) == 1) { nbCol = 3; sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, selectedRGB); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; } if (nbOutputArgument(pvApiCtx) >= 2) { nbCol = 1; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } redAdr[0] = selectedRGB[0]; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } greenAdr[0] = selectedRGB[1]; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } blueAdr[0] = selectedRGB[2]; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3; } } else /* The user canceled */ { nbRow = 0; nbCol = 0; if (nbOutputArgument(pvApiCtx) == 1) { /* Return [] */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; } if (nbOutputArgument(pvApiCtx) >= 2) { sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr); 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; } } 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; }
/*--------------------------------------------------------------------------*/ 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 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 sci_plot2d(char* fname, void *pvApiCtx) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; double* lt = NULL; int iTypel1 = 0; int iTypel2 = 0; int lw = 0; int m1 = 0, n1 = 0, m2 = 0, n2 = 0; int test = 0, i = 0, j = 0, iskip = 0; int frame_def = 8; int *frame = &frame_def; int axes_def = 1; int *axes = &axes_def; /* F.Leray 18.05.04 : log. case test*/ int size_x = 0, size_y = 0; char dataflag = 0; char* logFlags = NULL; int* style = NULL; double* rect = NULL; char* strf = NULL; char* legend = NULL; int* nax = NULL; BOOL flagNax = FALSE; char strfl[4]; BOOL freeStrf = FALSE; rhs_opts opts[] = { { -1, "axesflag", -1, 0, 0, NULL}, { -1, "frameflag", -1, 0, 0, NULL}, { -1, "leg", -1, 0, 0, NULL}, { -1, "logflag", -1, 0, 0, NULL}, { -1, "nax", -1, 0, 0, NULL}, { -1, "rect", -1, 0, 0, NULL}, { -1, "strf", -1, 0, 0, NULL}, { -1, "style", -1, 0, 0, NULL}, { -1, NULL, -1, 0, 0, NULL} }; if (nbInputArgument(pvApiCtx) == 0) { sci_demo(fname, pvApiCtx); return 0; } CheckInputArgument(pvApiCtx, 1, 9); iskip = 0; if (getOptionals(pvApiCtx, fname, opts) == 0) { ReturnArguments(pvApiCtx); return 0; } if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { /* logflags */ GetLogflags(pvApiCtx, fname, 1, opts, &logFlags); iskip = 1; } if (FirstOpt(pvApiCtx) == 2 + iskip) /** plot2d([loglags,] y, <opt_args>); **/ { sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getVarType(pvApiCtx, piAddrl2, &iTypel2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // the argument can be a matrix of doubles or other // If it is not a matrix of doubles, call overload if (iTypel2 == sci_matrix) { // Retrieve a matrix of double at position 1 + iskip. 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, 1 + iskip); return 1; } } else { OverLoad(1); return 0; } if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1; } m1 = m2; n1 = n2; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (i = 0; i < m2 ; ++i) { for (j = 0 ; j < n2 ; ++j) { *(l1 + i + m2 * j) = (double) i + 1; } } } else if (FirstOpt(pvApiCtx) >= 3 + iskip) /** plot2d([loglags,] x, y[, style [,...]]); **/ { /* x */ sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getVarType(pvApiCtx, piAddrl1, &iTypel1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // x can be a matrix of doubles or other // If x is not a matrix of doubles, call overload if (iTypel1 == sci_matrix) { // Retrieve a matrix of double at position 1 + iskip. 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 + iskip); return 1; } } else { OverLoad(1); return 0; } /* y */ sciErr = getVarAddressFromPosition(pvApiCtx, 2 + iskip, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getVarType(pvApiCtx, piAddrl2, &iTypel2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // y can be a matrix of doubles or other // If y is not a matrix of doubles, call overload if (iTypel2 == sci_matrix) { // Retrieve a matrix of double at position 1 + iskip. 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 + iskip); return 1; } } else { OverLoad(2); return 0; } test = (m1 * n1 == 0) || ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 == 1) && (m1 * n1 == m2 * n2)) || ((m1 == m2) && (n1 == n2)) || ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2)); //CheckDimProp if (!test) { Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname); return 1; } if (m1 * n1 == 0) { /* default x=1:n */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, <); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1; } for (i = 0; i < m2 ; ++i) { for (j = 0 ; j < n2 ; ++j) { *(lt + i + m2 * j) = (double) i + 1; } } m1 = m2; n1 = n2; l1 = lt; } else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1)) { /* a single x vector for mutiple columns for y */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, <); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (i = 0; i < m2 ; ++i) { for (j = 0 ; j < n2 ; ++j) { *(lt + i + m2 * j) = *(l1 + i); } } m1 = m2; n1 = n2; l1 = lt; } else if ((m1 == 1 && n1 == 1) && (n2 != 1)) { /* a single y row vector for a single x */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n2, <); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (j = 0 ; j < n2 ; ++j) { lt[j] = *l1; } n1 = n2; l1 = lt; } else { if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1; } if (m1 == 1 && n1 > 1) { m1 = n1; n1 = 1; } } } else { Scierror(999, _("%s: Wrong number of mandatory input arguments. At least %d expected.\n"), fname, 1); return 0; } if (n1 == -1 || n2 == -1 || m1 == -1 || m2 == -1) { Scierror(999, _("%s: Wrong size for input arguments #%d and #%d.\n"), fname, 1, 2); /* @TODO : detail error */ return 0; } sciGetStyle(pvApiCtx, fname, 3 + iskip, n1, opts, &style); GetStrf(pvApiCtx, fname, 4 + iskip, opts, &strf); GetLegend(pvApiCtx, fname, 5 + iskip, opts, &legend); GetRect(pvApiCtx, fname, 6 + iskip, opts, &rect); GetNax(pvApiCtx, 7 + iskip, opts, &nax, &flagNax); if (iskip == 0) { GetLogflags(pvApiCtx, fname, 8, opts, &logFlags); } freeStrf = !isDefStrf(strf); // Check strf [0-1][0-8][0-5] if (!isDefStrf(strf) && (strlen(strf) != 3 || strf[0] < '0' || strf[0] > '1' || strf[1] < '0' || strf[1] > '8' || strf[2] < '0' || strf[2] > '5')) { Scierror(999, _("%s: Wrong value for strf option: %s.\n"), fname, strf); if (freeStrf) { freeAllocatedSingleString(strf); } return -1; } if (isDefStrf(strf)) { strcpy(strfl, DEFSTRFN); strf = strfl; if (!isDefRect(rect)) { strfl[1] = '7'; } if (!isDefLegend(legend)) { strfl[0] = '1'; } GetOptionalIntArg(pvApiCtx, fname, 9, "frameflag", &frame, 1, opts); if (frame != &frame_def) { if (*frame >= 0 && *frame <= 8) { strfl[1] = (char)(*frame + 48); } else { Scierror(999, _("%s: Wrong value for frameflag option.\n"), fname); if (freeStrf) { freeAllocatedSingleString(strf); } return -1; } } GetOptionalIntArg(pvApiCtx, fname, 9, "axesflag", &axes, 1, opts); if (axes != &axes_def) { if ((*axes >= 0 && *axes <= 5) || *axes == 9) { strfl[2] = (char)(*axes + 48); } else { Scierror(999, _("%s: Wrong value for axesflag option.\n"), fname); if (freeStrf) { freeAllocatedSingleString(strf); } return -1; } } } /* Make a test on log. mode : available or not depending on the bounds set by Rect arg. or xmin/xmax : Rect case : - if the min bound is strictly posivite, we can use log. mode - if not, send error message x/y min/max case: - we find the first strictly positive min bound in Plo2dn.c ?? */ switch (strf[1]) { case '0': /* no computation, the plot use the previous (or default) scale */ break; case '1' : case '3' : case '5' : case '7': /* based on Rect arg */ if (rect[0] > rect[2] || rect[1] > rect[3]) { if (freeStrf) { freeAllocatedSingleString(strf); } Scierror(999, _("%s: Impossible status min > max in x or y rect data.\n"), fname); return -1; } if (rect[0] <= 0. && logFlags[1] == 'l') /* xmin */ { if (freeStrf) { freeAllocatedSingleString(strf); } Scierror(999, _("%s: Bounds on x axis must be strictly positive to use logarithmic mode.\n"), fname); return -1; } if (rect[1] <= 0. && logFlags[2] == 'l') /* ymin */ { if (freeStrf) { freeAllocatedSingleString(strf); } Scierror(999, _("%s: Bounds on y axis must be strictly positive to use logarithmic mode.\n"), fname); return -1; } break; case '2' : case '4' : case '6' : case '8': case '9': /* computed from the x/y min/max */ if ((int)strlen(logFlags) < 1) { dataflag = 'g'; } else { dataflag = logFlags[0]; } switch (dataflag) { case 'e' : size_x = (m1 != 0) ? 2 : 0; break; case 'o' : size_x = m1; break; case 'g' : default : size_x = (n1 * m1); break; } if (size_x != 0) { if (logFlags[1] == 'l' && sciFindStPosMin((l1), size_x) <= 0.0) { if (freeStrf) { freeAllocatedSingleString(strf); } Scierror(999, _("%s: At least one x data must be strictly positive to compute the bounds and use logarithmic mode.\n"), fname); return -1; } } size_y = (n1 * m1); if (size_y != 0) { if (logFlags[2] == 'l' && sciFindStPosMin((l2), size_y) <= 0.0) { if (freeStrf) { freeAllocatedSingleString(strf); } Scierror(999, _("%s: At least one y data must be strictly positive to compute the bounds and use logarithmic mode\n"), fname); return -1; } } break; } // open a figure if none already exists getOrCreateDefaultSubwin(); Objplot2d (1, logFlags, (l1), (l2), &n1, &m1, style, strf, legend, rect, nax, flagNax); // Allocated by sciGetStyle (get_style_arg function in GetCommandArg.c) FREE(style); if (freeStrf) { freeAllocatedSingleString(strf); } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_ClipBoard(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddr1 = NULL; int* piAddrl1 = NULL; int* piAddrStr = NULL; double* pdbll1 = NULL; int* pil1 = NULL; static int n1 = 0, m1 = 0; char* param1 = NULL; char* param2 = NULL; nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx)); CheckInputArgument(pvApiCtx, 0, 2); CheckOutputArgument(pvApiCtx, 0, 1); if ( getScilabMode() != SCILAB_NWNI ) { /*--------------------*/ /* clipboard("paste") */ /*--------------------*/ if (nbInputArgument(pvApiCtx) == 1) { if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { 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, ¶m1)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } if ( ( strcmp(param1, "paste") == 0 ) || ( strcmp(param1, "pastespecial") == 0 ) ) { /* Use the Java clipboard (CallScilabBridge.java returns "" if clipboard could not be read) */ char *output = getClipboardContents(); m1 = (int)strlen(output); n1 = 1; if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, output)) { freeAllocatedSingleString(param1); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } /* TO DO a delete [] and not a FREE */ FREE(output); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; freeAllocatedSingleString(param1); ReturnArguments(pvApiCtx); return TRUE; } else { freeAllocatedSingleString(param1); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "paste", "pastespecial"); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1); return FALSE; } } else if (nbInputArgument(pvApiCtx) == 2) { if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { /* Get the first argument: should be "copy" or "do" */ 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, ¶m1)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } if (( strcmp(param1, "do") != 0 ) && ( strcmp(param1, "copy") != 0 )) { freeAllocatedSingleString(param1); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "do", "copy"); return FALSE; } if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { /*-------------------------------------------*/ /* clipboard("do", {"paste","copy","empty"}) */ /*-------------------------------------------*/ /* @TODO : should be remplaced by an enum */ if ( strcmp(param1, "do") == 0 ) { freeAllocatedSingleString(param1); sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrl1, ¶m2)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if ( strcmp(param2, "paste") == 0 ) { /* Call Java to do the job */ pasteClipboardIntoConsole(); } else if ( strcmp(param2, "copy") == 0 ) { /* Call Java to do the job */ copyConsoleSelection(); } else if ( strcmp(param2, "empty") == 0 ) { /* Call Java to do the job */ emptyClipboard(); } else { freeAllocatedSingleString(param2); Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s' or '%s' expected.\n"), fname, 2, "copy", "paste", "empty"); return FALSE; } m1 = 0; n1 = 0; freeAllocatedSingleString(param2); sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; } /*-------------------------*/ /* clipboard("copy", data) */ /*-------------------------*/ else if ( strcmp(param1, "copy") == 0 ) { char *TextToPutInClipboard = NULL; char **Str = NULL; int m2 = 0, n2 = 0; freeAllocatedSingleString(param1); 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, &m2, &n2, &Str)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if (m2 * n2 == 1) /* Single line copy */ { TextToPutInClipboard = Str[0]; /* Call Java to do the job */ setClipboardContents(TextToPutInClipboard); } else /* Multi-line copy */ { int i = 0, j = 0, l2 = 0; char *TextToSendInClipboard = NULL; int SizeofTextToSendInClipboard = 0; char **buffer = (char**)MALLOC( (m2 * n2) * sizeof(char *) ); if (buffer == NULL) { freeAllocatedMatrixOfString(m2, n2, Str); Scierror(999, _("%s: No more memory.\n"), fname); return FALSE; } for (i = 0; i < m2; i++) { for (j = 0; j < n2; j++) { SizeofTextToSendInClipboard = SizeofTextToSendInClipboard + (int)strlen(Str[j * m2 + i]) + (int)strlen("\n") + (int)strlen(" "); buffer[i * n2 + j] = os_strdup(Str[j * m2 + i]); } } TextToSendInClipboard = (char*)MALLOC( (SizeofTextToSendInClipboard) * sizeof(char) ); if (TextToSendInClipboard == NULL) { freeAllocatedMatrixOfString(m2, n2, Str); Scierror(999, _("%s: No more memory.\n"), fname); freeArrayOfString(buffer, m2 * n2); return FALSE; } strcpy(TextToSendInClipboard, ""); for (i = 0; i < m2; i++) { for (j = 0; j < n2; j++) { strcat(TextToSendInClipboard, buffer[l2++]); strcat(TextToSendInClipboard, " "); } if ( i != (m2 - 1) ) { strcat(TextToSendInClipboard, "\n"); } } /* Call Java to do the job */ setClipboardContents(TextToSendInClipboard); FREE(buffer); buffer = NULL; freeArrayOfString(buffer, m2 * n2); FREE(TextToSendInClipboard); TextToSendInClipboard = NULL; } freeAllocatedMatrixOfString(m2, n2, Str); m1 = 0; n1 = 0; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; } } else { freeAllocatedSingleString(param1); Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return FALSE; } } /*----------------------------------*/ /* clipboard(fignum, {"EMF","DIB"}) */ /*----------------------------------*/ else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) { int num_win = -2; 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, &m1, &n1, &pil1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } num_win = pil1[0]; if (m1 * n1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1); return FALSE; } if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrl1, ¶m2)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if ( ( strcmp(param2, "EMF") == 0 ) || ( strcmp(param2, "DIB") == 0 ) ) { if (num_win >= 0) { /* Call Java */ if ( strcmp(param2, "EMF") == 0) { /* @TODO create EMF */ copyFigureToClipBoard(getFigureFromIndex(num_win)); } else { /* @TODO create DIB */ copyFigureToClipBoard(getFigureFromIndex(num_win)); } m1 = 0; n1 = 0; freeAllocatedSingleString(param2); sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; } else { freeAllocatedSingleString(param2); Scierror(999, _("%s: Wrong value for input argument #%d: Must be >= %d expected.\n"), fname, 1, 0); return FALSE; } } else { freeAllocatedSingleString(param2); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "EMF", "DIB"); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string or real expected.\n"), fname, 1); return FALSE; } } } else { Scierror(999, _("%s: Function not available in NWNI mode.\n"), fname); return FALSE; } return FALSE; }