/*--------------------------------------------------------------------------*/ 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_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_sym_set_int_param(char *fname, unsigned long fname_len){ // Error management variable SciErr sciErr1,sciErr2; double status=1.0;//assume error status double num;//to store and check the value obtained is pure unsigned integer int output;//output variable to store the return value of symphony set integer function int value;//to store the value of integer to be set int *piAddressVarOne = NULL;//pointer used to access first argument of the function int *piAddressVarTwo=NULL;//pointer used to access second argument of the function char variable_name[100];//string to hold the name of variable's value to be set char *ptr=variable_name;//pointer to point to address of the variable name CheckInputArgument(pvApiCtx, 2, 2);//Check we have exactly two argument as input or not CheckOutputArgument(pvApiCtx, 1, 1);//Check we have exactly no argument on output side or not //load address of 1st argument into piAddressVarOne sciErr1 = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne); sciErr2 = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo); //check whether there is an error or not. if (sciErr1.iErr){ printError(&sciErr1, 0); return 0; } if (sciErr2.iErr){ printError(&sciErr2, 0); return 0; } //read the value in that pointer pointing to variable name int err1=getAllocatedSingleString(pvApiCtx, piAddressVarOne, &ptr); //read the value of the variable to be set as a double value int err2=getScalarDouble(pvApiCtx, piAddressVarTwo, &num); //check for the integrity of integer value obtained if((double)(unsigned int)num!=(double)num) return 0; else value=(unsigned int)num;//if the value passed is an integer ,store it as an unsigned integer in value variable //ensure that environment is active if(global_sym_env==NULL){ sciprint("Error: Symphony environment not initialized. Please run 'sym_open()' first.\n"); } else { output=sym_set_int_param(global_sym_env,ptr,value);//symphony function to set the variable name pointed by the ptr pointer to the integer value stored in value variable. if(output==FUNCTION_TERMINATED_NORMALLY){ sciprint("setting of integer parameter function executed successfully\n"); status=0.0; } else if(output==FUNCTION_TERMINATED_ABNORMALLY){ sciprint("setting of integer parameter was unsuccessful.....check your parameter and value\n"); status=1.0; } else sciprint("\nerror while executing the setting integer function...check your parameter and value!!\n"); } int e=createScalarDouble(pvApiCtx,nbInputArgument(pvApiCtx)+1,status); if (e){ AssignOutputVariable(pvApiCtx, 1) = 0; return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; }
/* ==================================================================== */ int sci_foo(char *fname, void* pvApiCtx, unsigned long fname_len) { // Error management variable SciErr sciErr; ////////// Variables declaration ////////// int m1 = 0, n1 = 0; int *piAddressVarOne = NULL; double *matrixOfDouble = NULL; double *newMatrixOfDouble = NULL; int m2 = 0, n2 = 0; int *piAddressVarTwo = NULL; int *matrixOfBoolean = NULL; int *newMatrixOfBoolean = NULL; int i = 0; ////////// Check the number of input and output arguments ////////// /* --> [c, d] = foo(a, b) */ /* check that we have only 2 input arguments */ /* check that we have only 2 output argument */ CheckInputArgument(pvApiCtx, 2, 2) ; CheckOutputArgument(pvApiCtx, 2, 2) ; ////////// Manage the first input argument (double) ////////// /* get Address of inputs */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } /* Check that the first input argument is a real matrix (and not complex) */ if ( !isDoubleType(pvApiCtx, piAddressVarOne) || isVarComplex(pvApiCtx, piAddressVarOne) ) { Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 1); return 0; } /* get matrix */ sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &matrixOfDouble); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } ////////// Manage the second input argument (boolean) ////////// /* get Address of inputs */ sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } if ( !isBooleanType(pvApiCtx, piAddressVarTwo) ) { Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, 2); return 0; } /* get matrix */ sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2, &matrixOfBoolean); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } ////////// Check the consistency of the two input arguments ////////// if ((m1 != m2) | - (n1 != n2)) { Scierror(999, _("%s: Wrong size for input arguments: Same size expected.\n"), fname, 1); return 0; } newMatrixOfDouble = (double*)malloc(sizeof(double) * m1 * n1); ////////// Application code ////////// // Could be replaced by a call to a library for (i = 0; i < m1 * n1; i++) { /* For each element of the matrix, multiply by 2 */ newMatrixOfDouble[i] = matrixOfDouble[i] * 2; } newMatrixOfBoolean = (int*)malloc(sizeof(double) * m2 * n2); for (i = 0; i < m2 * n2; i++) { /* For each element of the matrix, invert the value */ newMatrixOfBoolean[i] = matrixOfBoolean[i] == TRUE ? FALSE : TRUE; } ////////// Create the output arguments ////////// /* Create the matrix as return of the function */ sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, newMatrixOfDouble); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } /* Create the matrix as return of the function */ sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m2, n2, newMatrixOfBoolean); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } ////////// Return the output arguments to the Scilab engine ////////// AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_xfpolys(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; int* piAddr3 = NULL; int* l3 = NULL; int m1 = 0, n1 = 0; int m2 = 0, n2 = 0; int m3 = 0, n3 = 0; int mn2 = 0; int v1 = 0; /* v1 is the flag used for flat (v1==1) or interpolated (v1==2) shading */ int i = 0; long hdl = 0; char *pstSubWinUID = NULL; char *pstFigureUID = NULL; char *pstCompoundUID = NULL; int iSubWinForeground = 0; int iImmediateDrawing = 0; int *piImmediateDrawing = &iImmediateDrawing; int iFalse = 0; int iColorMapSize = 0; int* piColorMapSize = &iColorMapSize; int iForeGround = 0; int* piForeGround = &iForeGround; int iVisible = 0; int *piVisible = &iVisible; CheckInputArgument(pvApiCtx, 2, 3); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); return 1; } 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; } //CheckSameDims if (m1 != m2 || n1 != n2) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } mn2 = m2 * n2; if (mn2 == 0) { AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr3, &m3, &n3, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); return 1; } if (m3 * n3 == m1 * n1) { //CheckSameDims if (m1 != m3 || n1 != n3) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } v1 = 2; /* interpolated shading */ if (m3 != 3 && m3 != 4) { Scierror(999, _("%s: Interpolated shading only works for polygons of size %d or %d\n"), fname, 3, 4); return 0; } } else { //CheckVector if (m3 != 1 && n3 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 3); return 1; } //CheckDimProp if (m3 * n3 != n2) { Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname); return 1; } v1 = 1; /* flat shading */ } } else { int un = 1, ix = 0; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 3, un, n2, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (ix = 0; ix < n2; ++ix) { *(int*)(l3 + ix) = 0; } m3 = n3 = 1; } pstSubWinUID = (char*)getOrCreateDefaultSubwin(); getGraphicObjectProperty(pstSubWinUID, __GO_PARENT__, jni_string, (void**)&pstFigureUID); getGraphicObjectProperty(pstFigureUID, __GO_IMMEDIATE_DRAWING__, jni_bool, (void **)&piImmediateDrawing); setGraphicObjectProperty(pstFigureUID, __GO_IMMEDIATE_DRAWING__, &iFalse, jni_bool, 1); //get color map size getGraphicObjectProperty(pstFigureUID, __GO_COLORMAP_SIZE__, jni_int, (void**)&piColorMapSize); //get current foreground color getGraphicObjectProperty(pstSubWinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeGround); // Create compound. pstCompoundUID = createGraphicObject(__GO_COMPOUND__); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iFalse, jni_bool, 1); /* Sets the parent-child relationship for the Compound */ setGraphicObjectRelationship(pstSubWinUID, pstCompoundUID); for (i = 0; i < n1; ++i) { if (m3 == 1 || n3 == 1) /* color vector specified */ { if (*(int*)(l3 + i) == 0) { if (iForeGround == -1) { iSubWinForeground = iColorMapSize + 1; } else if (iForeGround == -2) { iSubWinForeground = iColorMapSize + 2; } else { iSubWinForeground = iForeGround; } Objpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, 1, iSubWinForeground, &hdl); } else { Objfpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, (int*)(l3 + i), &hdl, v1); } } else /* we have a color matrix used for interpolated shading : one color per vertex */ { Objfpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, (int*)(l3 + i * m3), &hdl, v1); } // Add newly created object to Compound setGraphicObjectRelationship(pstCompoundUID, getObjectFromHandle(hdl)); } setCurrentObject(pstCompoundUID); setGraphicObjectProperty(pstFigureUID, __GO_IMMEDIATE_DRAWING__, &piImmediateDrawing, jni_bool, 1); getGraphicObjectProperty(pstFigureUID, __GO_VISIBLE__, jni_bool, (void **)&piVisible); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iVisible, jni_bool, 1); AssignOutputVariable(pvApiCtx, 1) = 0; 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_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_xstringb(char *fname, void *pvApiCtx) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; int* piAddrStr = NULL; int* piAddrl4 = NULL; double* l4 = NULL; int* piAddrl5 = NULL; double* l5 = NULL; int* piAddrl6 = NULL; char* l6 = NULL; int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, m5 = 0, n5 = 0, m6 = 0, n6 = 0; BOOL autoSize = TRUE ; double x = 0., y = 0., w = 0., hx = 0.; char **Str = NULL; double rect[4], angle = 0.; long hdlstr = 0; double userSize[2] ; int textBoxMode = 1; // 0 : off | 1 : centered | 2 : filled if ( nbInputArgument(pvApiCtx) <= 0 ) { /* demo */ sci_demo(fname, pvApiCtx); return 0 ; } CheckInputArgument(pvApiCtx, 5, 6); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } //CheckScalar if (m1 != 1 || n1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 1); return 1; } x = *l1; sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l2". sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2); return 1; } //CheckScalar if (m2 != 1 || n2 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2); return 1; } y = *l2; sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrStr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m3, &n3, &Str)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if ( m3*n3 == 0 ) { AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrl4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl4, &m4, &n4, &l4); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4); return 1; } //CheckScalar if (m4 != 1 || n4 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4); return 1; } w = *l4; sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrl5); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 5. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl5, &m5, &n5, &l5); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 5); return 1; } //CheckScalar if (m5 != 1 || n5 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 5); return 1; } hx = *l5; if (nbInputArgument(pvApiCtx) == 6) { sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddrl6); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a string at position 6. if (isScalar(pvApiCtx, piAddrl6) == 0) { Scierror(999, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 6); return 1; } if (getAllocatedSingleString(pvApiCtx, piAddrl6, &l6)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 6); return 1; } if (strcmp(l6, "fill") == 0 ) { autoSize = FALSE ; textBoxMode = 2; } else { Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 6, "fill"); return 0; } freeAllocatedSingleString(l6); } userSize[0] = w ; userSize[1] = hx ; Objstring (Str, m3, n3, x, y, &angle, rect, autoSize, userSize, &hdlstr, textBoxMode, NULL, NULL, FALSE, TRUE, FALSE, ALIGN_CENTER); freeArrayOfString(Str, m3 * n3); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_fftw_flags(char *fname, unsigned long fname_len) { /* declaration of variables to store scilab parameters address */ static int m1 = 0, n1 = 0; char **Str1 = NULL; char **Str3 = NULL; unsigned int uiVar1 = 0; int* piDataOut = NULL; int* piAddr1 = NULL; int* piLen = NULL; int iType = 0; /* please update me ! */ static int nb_flag = 22; static char *Str[] = { /* documented flags */ "FFTW_MEASURE", "FFTW_DESTROY_INPUT", "FFTW_UNALIGNED", "FFTW_CONSERVE_MEMORY", "FFTW_EXHAUSTIVE", "FFTW_PRESERVE_INPUT", "FFTW_PATIENT", "FFTW_ESTIMATE", /* undocumented beyond-guru flags */ "FFTW_ESTIMATE_PATIENT", "FFTW_BELIEVE_PCOST", "FFTW_NO_DFT_R2HC", "FFTW_NO_NONTHREADED", "FFTW_NO_BUFFERING", "FFTW_NO_INDIRECT_OP", "FFTW_ALLOW_LARGE_GENERIC", "FFTW_NO_RANK_SPLITS", "FFTW_NO_VRANK_SPLITS", "FFTW_NO_VRECURSE", "FFTW_NO_SIMD", "FFTW_NO_SLOW", "FFTW_NO_FIXED_RADIX_LARGE_N", "FFTW_ALLOW_PRUNING" }; static unsigned flagt[] = { /* documented flags */ FFTW_MEASURE, FFTW_DESTROY_INPUT, FFTW_UNALIGNED, FFTW_CONSERVE_MEMORY, FFTW_EXHAUSTIVE, FFTW_PRESERVE_INPUT, FFTW_PATIENT, FFTW_ESTIMATE, /* undocumented beyond-guru flags */ FFTW_ESTIMATE_PATIENT, FFTW_BELIEVE_PCOST, FFTW_NO_DFT_R2HC, FFTW_NO_NONTHREADED, FFTW_NO_BUFFERING, FFTW_NO_INDIRECT_OP, FFTW_ALLOW_LARGE_GENERIC, FFTW_NO_RANK_SPLITS, FFTW_NO_VRANK_SPLITS, FFTW_NO_VRECURSE, FFTW_NO_SIMD, FFTW_NO_SLOW, FFTW_NO_FIXED_RADIX_LARGE_N, FFTW_ALLOW_PRUNING }; unsigned flagv = 0; int i = 0, j = 0; SciErr sciErr; CheckInputArgument(pvApiCtx, 0, 1); if (nbInputArgument(pvApiCtx) == 0) { // nothing } else { //get variable address of the input argument sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } getVarType(pvApiCtx, piAddr1, &iType); switch (iType) { case sci_ints: { /* int */ int iPrecision = 0; int* pi32Data = NULL; unsigned int* pui32Data = NULL; getMatrixOfIntegerPrecision(pvApiCtx, piAddr1, &iPrecision); if (iPrecision != SCI_INT32 && iPrecision != SCI_UINT32) { Scierror(999, _("%s: Wrong type for input argument #%d: A int32 expected.\n"), fname, 1); return 1; } if (iPrecision == SCI_INT32) { sciErr = getMatrixOfInteger32(pvApiCtx, piAddr1, &m1, &n1, pi32Data); uiVar1 = (unsigned int)pi32Data[0]; } else { sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr1, &m1, &n1, pui32Data); uiVar1 = pui32Data[0]; } if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1); printError(&sciErr, 0); return 1; } break; } case sci_matrix: { /* double */ double* pdblData = NULL; sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &pdblData); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1); printError(&sciErr, 0); return 1; } uiVar1 = (unsigned int)pdblData[0]; break; } case sci_strings: { /* string */ //fisrt call to retrieve dimensions sciErr = getMatrixOfString(pvApiCtx, piAddr1, &m1, &n1, NULL, NULL); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } piLen = (int*)malloc(sizeof(int) * m1 * n1); //second call to retrieve length of each string sciErr = getMatrixOfString(pvApiCtx, piAddr1, &m1, &n1, piLen, NULL); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } Str1 = (char**)malloc(sizeof(char*) * m1 * n1); for (i = 0 ; i < m1 * n1 ; i++) { Str1[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination } //third call to retrieve data sciErr = getMatrixOfString(pvApiCtx, piAddr1, &m1, &n1, piLen, Str1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } for (j = 0; j < m1 * n1; j++) { for (i = 0; i < nb_flag; i++) { if (strcmp(Str1[j], Str[i]) == 0) { break; } } if (i == nb_flag) { freeArrayOfString(Str1, m1 * n1); Scierror(999, _("%s: Wrong values for input argument #%d: FFTW flag expected.\n"), fname, 1); return 0; } else { if (i > 0) { flagv = ( flagv | (1U << (i - 1)) ); } } } uiVar1 = (unsigned int)flagv; freeArrayOfString(Str1, m1 * n1); m1 = 1; n1 = 1; break; } default: Scierror(53, _("%s: Wrong type for input argument #%d.\n"), fname, 1); return 1; } CheckDims(1, m1, n1, 1, 1); setCurrentFftwFlags(uiVar1); } /* return value of Sci_Plan.flags in position 2 */ sciErr = allocMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 1, &piDataOut); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: No more memory.\n"), fname); return 1; } piDataOut[0] = (int) getCurrentFftwFlags(); /*Test for only FFTW_MEASURE*/ if (getCurrentFftwFlags() == 0) { j = 1; if ((Str3 = (char **)MALLOC(sizeof(char *))) == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); return 1; } Str3[0] = strdup(Str[0]); if (Str3[0] == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); return 1; } } else { j = 0; for (i = 1; i < nb_flag; i++) { if ((getCurrentFftwFlags() & flagt[i]) == flagt[i]) { j++; if (Str3) { Str3 = (char **)REALLOC(Str3, sizeof(char *) * j); } else { Str3 = (char **)MALLOC(sizeof(char *) * j); } if ( Str3 == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); return 1; } Str3[j - 1] = strdup(Str[i]); if (Str3[j - 1] == NULL) { freeArrayOfString(Str3, j); Scierror(999, _("%s: No more memory.\n"), fname); return 1; } } } } /* Create the string matrix as return of the function */ sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 3, j, 1, Str3); freeArrayOfString(Str3, j); // Data have been copied into Scilab memory if (sciErr.iErr) { freeArrayOfString(Str3, j); // Make sure everything is cleanup in case of error printError(&sciErr, 0); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 2; AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 3; ReturnArguments(pvApiCtx); return 0; }
int sci_eigs(char *fname, void* pvApiCtx) { SciErr sciErr; int *piAddressVarOne = NULL; int iRowsOne = 0; int iColsOne = 0; double elemt1 = 0; double elemt2 = 0; double* Areal = NULL; doublecomplex* Acplx = NULL; int Asym = 1; int Acomplex = 0; int N = 0; int *piAddressVarTwo = NULL; int iTypeVarTwo = 0; int iRowsTwo = 0; int iColsTwo = 0; double* Breal = NULL; doublecomplex* Bcplx = NULL; int Bcomplex = 0; int matB = 0; int *piAddressVarThree = NULL; double dblNEV = 0; int iNEV = 0; int *piAddressVarFour = NULL; int iTypeVarFour = 0; int iRowsFour = 0; int iColsFour = 0; char* pstData = NULL; doublecomplex SIGMA; int *piAddressVarFive = NULL; double dblMAXITER = 0; int *piAddressVarSix = NULL; double dblTOL = 0; int *piAddressVarSeven = NULL; int TypeVarSeven = 0; int RowsSeven = 0; int ColsSeven = 0; double* dblNCV = NULL; int *piAddressVarEight = NULL; int iTypeVarEight = 0; double dblCHOLB = 0; int iCHOLB = 0; int *piAddressVarNine = NULL; int iTypeVarNine = 0; int iRowsNine = 0; int iColsNine = 0; double* RESID = NULL; doublecomplex* RESIDC = NULL; int *piAddressVarTen = NULL; int iINFO = 0; int RVEC = 0; // Output arguments double* eigenvalue = NULL; double* eigenvector = NULL; doublecomplex* eigenvalueC = NULL; doublecomplex* eigenvectorC = NULL; double* mat_eigenvalue = NULL; doublecomplex* mat_eigenvalueC = NULL; int INFO_EUPD = 0; int error = 0; int iErr = 0; int i = 0; int j = 0; CheckInputArgument(pvApiCtx, 1, 10); CheckOutputArgument(pvApiCtx, 0, 2); /**************************************** * First variable : A * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1); return 1; } sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &iRowsOne, &iColsOne); //check if A is a square matrix if (iRowsOne * iColsOne == 1 || iRowsOne != iColsOne) { Scierror(999, _("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1); return 1; } N = iRowsOne; //check if A is complex if (isVarComplex(pvApiCtx, piAddressVarOne)) { sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddressVarOne, &iRowsOne, &iColsOne, &Acplx); Acomplex = 1; } else { sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &iRowsOne, &iColsOne, &Areal); for (i = 0; i < iColsOne; i++) { for (j = 0; j < i; j++) { elemt1 = Areal[j + i * iColsOne]; elemt2 = Areal[j * iColsOne + i]; if (fabs(elemt1 - elemt2) > 0) { Asym = 0; break; } } if (Asym == 0) { break; } } } /**************************************** * Second variable : B * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2); return 1; } sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iTypeVarTwo); if (sciErr.iErr || iTypeVarTwo != sci_matrix) { printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2); return 1; } sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo); matB = iRowsTwo * iColsTwo; if (matB && (iRowsTwo != iRowsOne || iColsTwo != iColsOne)) { Scierror(999, _("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2); return 1; } if (isVarComplex(pvApiCtx, piAddressVarTwo)) { sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo, &Bcplx); Bcomplex = 1; } else { sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo, &Breal); } if (matB != 0) { if (Acomplex && !Bcomplex) { Bcplx = (doublecomplex*)MALLOC(N * N * sizeof(doublecomplex)); memset(Bcplx, 0, N * N * sizeof(doublecomplex)); Bcomplex = 1; for (i = 0 ; i < N * N ; i++) { Bcplx[i].r = Breal[i]; } } if (!Acomplex && Bcomplex) { Acplx = (doublecomplex*)MALLOC(N * N * sizeof(doublecomplex)); memset(Acplx, 0, N * N * sizeof(doublecomplex)); Acomplex = 1; for (i = 0 ; i < N * N ; i++) { Acplx[i].r = Areal[i]; } } } /**************************************** * NEV * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3); FREE_AB; return 1; } iErr = getScalarDouble(pvApiCtx, piAddressVarThree, &dblNEV); if (iErr) { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3); FREE_AB; return 1; } if (isVarComplex(pvApiCtx, piAddressVarThree)) { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3); FREE_AB; return 1; } if (dblNEV != floor(dblNEV) || (dblNEV <= 0)) { Scierror(999, _("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3); FREE_AB; return 1; } if (!finite(dblNEV)) { Scierror(999, _("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3); FREE_AB; return 1; } iNEV = (int)dblNEV; /**************************************** * SIGMA AND WHICH * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarFour); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4); FREE_AB; return 1; } sciErr = getVarType(pvApiCtx, piAddressVarFour, &iTypeVarFour); if (sciErr.iErr || (iTypeVarFour != sci_matrix && iTypeVarFour != sci_strings)) { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4); FREE_AB; return 1; } if (iTypeVarFour == sci_strings) { int iErr = getAllocatedSingleString(pvApiCtx, piAddressVarFour, &pstData); if (iErr) { FREE_AB; return 1; } if (strcmp(pstData, "LM") != 0 && strcmp(pstData, "SM") != 0 && strcmp(pstData, "LR") != 0 && strcmp(pstData, "SR") != 0 && strcmp(pstData, "LI") != 0 && strcmp(pstData, "SI") != 0 && strcmp(pstData, "LA") != 0 && strcmp(pstData, "SA") != 0 && strcmp(pstData, "BE") != 0) { if (!Acomplex && Asym) { Scierror(999, _("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s' or '%s'.\n" ), "eigs", 4, "LM", "SM", "LA", "SA", "BE"); freeAllocatedSingleString(pstData); return 1; } else { Scierror(999, _("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s', '%s' or '%s'.\n " ), "eigs", 4, "LM", "SM", "LR", "SR", "LI", "SI"); FREE_AB; freeAllocatedSingleString(pstData); return 1; } } if ((Acomplex || !Asym) && (strcmp(pstData, "LA") == 0 || strcmp(pstData, "SA") == 0 || strcmp(pstData, "BE") == 0)) { Scierror(999, _("%s: Invalid sigma value for complex or non symmetric problem.\n"), "eigs", 4); FREE_AB; freeAllocatedSingleString(pstData); return 1; } if (!Acomplex && Asym && (strcmp(pstData, "LR") == 0 || strcmp(pstData, "SR") == 0 || strcmp(pstData, "LI") == 0 || strcmp(pstData, "SI") == 0)) { Scierror(999, _("%s: Invalid sigma value for real symmetric problem.\n"), "eigs", 4); freeAllocatedSingleString(pstData); return 1; } SIGMA.r = 0; SIGMA.i = 0; } if (iTypeVarFour == sci_matrix) { sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &iRowsFour, &iColsFour); if (iRowsFour * iColsFour != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4); FREE_AB; return 1; } if (getScalarComplexDouble(pvApiCtx, piAddressVarFour, &SIGMA.r, &SIGMA.i)) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4); FREE_AB; return 1; } if (C2F(isanan)(&SIGMA.r) || C2F(isanan)(&SIGMA.i)) { Scierror(999, _("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4); FREE_AB; return 1; } pstData = "LM"; } /**************************************** * MAXITER * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddressVarFive); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 5); FREE_AB; FREE_PSTDATA; return 0; } iErr = getScalarDouble(pvApiCtx, piAddressVarFive, &dblMAXITER); if (iErr) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter"); FREE_AB; FREE_PSTDATA; return 1; } if ((dblMAXITER != floor(dblMAXITER)) || (dblMAXITER <= 0)) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter"); FREE_AB; FREE_PSTDATA; return 1; } /**************************************** * TOL * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddressVarSix); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 6); FREE_AB; FREE_PSTDATA; return 1; } iErr = getScalarDouble(pvApiCtx, piAddressVarSix, &dblTOL); if (iErr) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol"); FREE_AB; FREE_PSTDATA; return 1; } if (C2F(isanan)(&dblTOL)) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol"); FREE_AB; FREE_PSTDATA; return 1; } /**************************************** * NCV * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddressVarSeven); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 7); FREE_AB; FREE_PSTDATA; return 1; } sciErr = getVarType(pvApiCtx, piAddressVarSeven, &TypeVarSeven); if (sciErr.iErr || TypeVarSeven != sci_matrix) { printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv"); FREE_AB; FREE_PSTDATA; return 1; } else { if (isVarComplex(pvApiCtx, piAddressVarSeven)) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv"); } else { sciErr = getVarDimension(pvApiCtx, piAddressVarSeven, &RowsSeven, &ColsSeven); if (RowsSeven * ColsSeven > 1) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv"); FREE_AB; FREE_PSTDATA; return 1; } if (RowsSeven * ColsSeven == 1) { sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarSeven, &RowsSeven, &ColsSeven, &dblNCV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 7); FREE_AB; FREE_PSTDATA; return 1; } if (dblNCV[0] != floor(dblNCV[0])) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv"); FREE_AB; FREE_PSTDATA; return 1; } } } } /**************************************** * CHOLB * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddressVarEight); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 8); FREE_AB; FREE_PSTDATA; return 1; } sciErr = getVarType(pvApiCtx, piAddressVarEight, &iTypeVarEight); if (sciErr.iErr || (iTypeVarEight != sci_matrix && iTypeVarEight != sci_boolean)) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"); FREE_AB; FREE_PSTDATA; return 1; } if (iTypeVarEight == sci_boolean) { iErr = getScalarBoolean(pvApiCtx, piAddressVarEight, &iCHOLB); if (iErr) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"); FREE_AB; FREE_PSTDATA; return 1; } if (iCHOLB != 1 && iCHOLB != 0) { Scierror(999, _("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t"); FREE_AB; FREE_PSTDATA; return 1; } dblCHOLB = (double) iCHOLB; } if (iTypeVarEight == sci_matrix) { iErr = getScalarDouble(pvApiCtx, piAddressVarEight, &dblCHOLB); if (iErr) { Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB"); FREE_AB; FREE_PSTDATA; return 1; } if (dblCHOLB != 1 && dblCHOLB != 0) { Scierror(999, _("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t"); FREE_AB; FREE_PSTDATA; return 1; } } if ( dblCHOLB ) // check that B is upper triangular with non zero element on the diagonal { if (!Bcomplex) { for (i = 0; i < N; i++) { for (j = 0; j <= i; j++) { if (i == j && Breal[i + j * N] == 0) { Scierror(999, _("%s: B is not positive definite. Try with sigma='SM' or sigma=scalar.\n"), "eigs"); FREE_PSTDATA; return 0; } else { if ( j < i && Breal[i + j * N] != 0 ) { Scierror(999, _("%s: If opts.cholB is true, B should be upper triangular.\n"), "eigs"); FREE_PSTDATA; return 0; } } } } } else { for (i = 0; i < N; i++) { for (j = 0; j <= i; j++) { if (i == j && Bcplx[i + i * N].r == 0 && Bcplx[i + i * N].i == 0) { Scierror(999, _("%s: B is not positive definite. Try with sigma='SM' or sigma=scalar.\n"), "eigs"); FREE_AB; FREE_PSTDATA; return 0; } else { if ( j < i && (Bcplx[i + j * N].r != 0 || Bcplx[i + j * N].i != 0) ) { Scierror(999, _("%s: If opts.cholB is true, B should be upper triangular.\n"), "eigs"); FREE_AB; FREE_PSTDATA; return 0; } } } } } } /**************************************** * RESID * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 9, &piAddressVarNine); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 9); FREE_AB; FREE_PSTDATA; return 1; } sciErr = getVarType(pvApiCtx, piAddressVarNine, &iTypeVarNine); if (sciErr.iErr || iTypeVarNine != sci_matrix) { printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9); FREE_AB; FREE_PSTDATA; return 1; } else { sciErr = getVarDimension(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine); if (iRowsNine * iColsNine == 1 || iRowsNine * iColsNine != N) { Scierror(999, _("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid"); FREE_AB; FREE_PSTDATA; return 1; } } if (!Acomplex && !Bcomplex) { if (isVarComplex(pvApiCtx, piAddressVarNine)) { Scierror(999, _("%s: Wrong type for input argument #%d: Start vector %s must be real for real problems.\n"), "eigs", 9, "opts.resid"); FREE_PSTDATA; return 1; } else { sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine, &RESID); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9); FREE_PSTDATA; return 1; } } } else { sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine, &RESIDC); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9); FREE_AB; FREE_PSTDATA; return 1; } } /**************************************** * INFO * *****************************************/ sciErr = getVarAddressFromPosition(pvApiCtx, 10, &piAddressVarTen); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9); FREE_AB; FREE_PSTDATA; return 1; } iErr = getScalarInteger32(pvApiCtx, piAddressVarTen, &iINFO); if (iErr) { Scierror(999, _("%s: Wrong type for input argument #%d: An integer expected.\n"), "eigs", 1); FREE_AB; FREE_PSTDATA; return 1; } // Initialization output arguments if (nbOutputArgument(pvApiCtx) > 1) { RVEC = 1; } if (Acomplex || Bcomplex || !Asym) { eigenvalueC = (doublecomplex*)CALLOC((iNEV + 1), sizeof(doublecomplex)); if (RVEC) { eigenvectorC = (doublecomplex*)CALLOC(N * (iNEV + 1), sizeof(doublecomplex)); } } else { eigenvalue = (double*)CALLOC(iNEV, sizeof(double)); /* we should allocate eigenvector only if RVEC is true, but dseupd segfaults if Z is not allocated even when RVEC is false, contrary to the docs.*/ eigenvector = (double*)CALLOC(iNEV * N, sizeof(double)); } error = eigs(Areal, Acplx, N, Acomplex, Asym, Breal, Bcplx, Bcomplex, matB, iNEV, SIGMA, pstData, &dblMAXITER, &dblTOL, dblNCV, RESID, RESIDC, &iINFO, &dblCHOLB, INFO_EUPD, eigenvalue, eigenvector, eigenvalueC, eigenvectorC, RVEC); FREE_AB; FREE_PSTDATA; switch (error) { case -1 : if (Asym && !Acomplex && !Bcomplex) { Scierror(999, _("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7); } else { if (!Asym && !Acomplex && !Bcomplex) { Scierror(999, _("%s: Wrong value for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV <= N.\n"), "eigs", 7); } else { Scierror(999, _("%s: Wrong value for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "eigs", 7); } } ReturnArguments(pvApiCtx); return 1; case -2 : if (Asym && !Acomplex && !Bcomplex) { Scierror(999, _("%s: Wrong value for input argument #%d: For real symmetric problems, k must be an integer in the range 1 to N - 1.\n"), "eigs", 3); } else { Scierror(999, _("%s: Wrong value for input argument #%d: For real non symmetric or complex problems, k must be an integer in the range 1 to N - 2.\n"), "eigs", 3); } ReturnArguments(pvApiCtx); return 1; case -3 : Scierror(999, _("%s: Error with input argument #%d: B is not positive definite. Try with sigma='SM' or sigma=scalar.\n"), "eigs", 2); ReturnArguments(pvApiCtx); return 0; case -4 : if (!Acomplex && !Bcomplex) { if (Asym) { Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DSAUPD", iINFO); } else { Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DNAUPD", iINFO); } } else { Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "ZNAUPD", iINFO); } ReturnArguments(pvApiCtx); return 1; case -5 : if (!Acomplex && !Bcomplex) { if (Asym) { Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "DSAUPD"); } else { Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "DNAUPD"); } } else { Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "ZNAUPD"); } ReturnArguments(pvApiCtx); return 1; case -6 : if (!Acomplex && !Bcomplex) { if (Asym) { Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DSEUPD", INFO_EUPD); } else { Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DNEUPD", INFO_EUPD); } } else { Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "ZNEUPD", INFO_EUPD); } ReturnArguments(pvApiCtx); FREE(mat_eigenvalue); return 1; } if (nbOutputArgument(pvApiCtx) <= 1) { if (eigenvalue) { sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, 1, eigenvalue); FREE(eigenvalue); FREE(eigenvector); } else if (eigenvalueC) { sciErr = createComplexZMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, 1, eigenvalueC); FREE(eigenvalueC); } if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; } else { // create a matrix which contains the eigenvalues if (eigenvalue) { mat_eigenvalue = (double*)CALLOC(iNEV * iNEV, sizeof(double)); for (i = 0; i < iNEV; i++) { mat_eigenvalue[i * iNEV + i] = eigenvalue[i]; } sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, iNEV, mat_eigenvalue); FREE(eigenvalue); FREE(mat_eigenvalue); } else if (eigenvalueC) { mat_eigenvalueC = (doublecomplex*)CALLOC(iNEV * iNEV, sizeof(doublecomplex)); for (i = 0; i < iNEV; i++) { mat_eigenvalueC[i * iNEV + i] = eigenvalueC[i]; } sciErr = createComplexZMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, iNEV, mat_eigenvalueC); FREE(eigenvalueC); FREE(mat_eigenvalueC); } if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } if (eigenvector) { sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, N, iNEV, eigenvector); FREE(eigenvector); } else if (eigenvectorC) { sciErr = createComplexZMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, N, iNEV, eigenvectorC); FREE(eigenvectorC); } 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; } ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_fft_gen(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar, double *Ai, int isn, int iopt, guru_dim_struct gdim) { /* API variables */ SciErr sciErr; /* Input array variables */ int isrealA = (Ai == NULL), issymA = 1, lA = 1; /*for MKL*/ int isrealA_save = isrealA ; /*FFTW specific library variable */ enum Scaling scale = None; enum Plan_Type type; fftw_plan p; /* input/output address for transform variables */ double *ri = NULL, *ii = NULL, *ro = NULL, *io = NULL; /* for MKL special cases */ int * dims1 = NULL; int * incr1 = NULL; /* local variable */ int one = 1; int i = 0; int errflag = 0; for (i = 0; i < ndimsA; i++) { lA *= dimsA[i]; } if (iopt == 0) { /* automatically selected algorithm*/ issymA = check_array_symmetry(Ar, Ai, gdim); if (issymA < 0 ) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } } else if (iopt == 1) { issymA = 1; /* user forces symmetry */ } else { issymA = 0; } AssignOutputVariable(_pvCtx, 1) = 1;/* assume inplace transform*/ if (WITHMKL) { double dzero = 0.0; if (isrealA) { /*MKL does not implement the r2c nor r2r guru split methods, make A complex */ if (issymA) { /* result will be real, the imaginary part of A can be allocated alone */ sciErr = allocMatrixOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, 1, lA, &Ai); if (sciErr.iErr) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } C2F(dset)(&lA, &dzero, Ai, &one); } else { /* result will be complex, realloc A for inplace computation */ sciErr = allocComplexArrayOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, ndimsA, dimsA, &ri, &Ai); if (sciErr.iErr) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } C2F(dcopy)(&lA, Ar, &one, ri, &one); Ar = ri; C2F(dset)(&lA, &dzero, Ai, &one); AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1; isrealA = 0; } } } if (!isrealA && issymA) /* A is complex but result is real */ { /* result will be complex, realloc real part of A for real part inplace computation */ sciErr = allocArrayOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, ndimsA, dimsA, &ri); if (sciErr.iErr) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } C2F(dcopy)(&lA, Ar, &one, ri, &one); Ar = ri; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(_pvCtx) + 1; } /* Set pointers on real and imaginary part of the input */ ri = Ar; ii = Ai; scale = None; /*no scaling needed */ if (isn == FFTW_BACKWARD) scale = Divide; if (isrealA & !WITHMKL) /* To have type = C2C_PLAN*/ { /*A is real */ if (issymA) { /*r2r = isrealA && issymA*/ /* there is no general plan able to compute r2r transform so it is tranformed into a R2c plan. The computed imaginary part will be zero*/ sciErr = allocMatrixOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, 1, lA, &io); if (sciErr.iErr) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } type = R2C_PLAN; ro = Ar; } else { /*r2c = isrealA && ~issymA;*/ /* transform cannot be done in place */ sciErr = allocComplexArrayOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, ndimsA, dimsA, &ro, &io); if (sciErr.iErr) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(_pvCtx) + 1; type = R2C_PLAN; /* fftw_plan_guru_split_dft_r2c plans for an FFTW_FORWARD transform*/ if (isn == FFTW_BACKWARD) { /*transform problem into a FORWARD fft*/ /*ifft(A)=conj(fft(A/N)) cas vect*/ /* pre traitement A must be divided by N cas vect*/ /* post treatment result must conjugated */ } } } else { /* A is complex */ if (!WITHMKL && issymA) /*result is real*/ { /*c2r = ~isrealA && issymA*/ ro = ri; io = NULL; type = C2R_PLAN; /*fftw_plan_guru_split_dft_c2r plans for an FFTW_BACKWARD transform*/ if (isn == FFTW_FORWARD) { /*transform problem into a BACKWARD fft : fft(A)=ifft(conj(A))*/ double minusone = -1.0; C2F(dscal)(&lA, &minusone, ii, &one); } } else { /*c2c = ~isrealA && ~issymA;*/ /* use inplace transform*/ isrealA = 0; type = C2C_PLAN; /* fftw_plan_guru_split_dft plans for an FFTW_FORWARD transform*/ if (isn == FFTW_BACKWARD) { /*transform problem into a FORWARD fft*/ /* ifft(A) = %i*conj(fft(%i*conj(A)/N) */ /* reverse input */ ri = Ai; ii = Ar; /* reverse output */ ro = Ai; io = Ar; } else { ro = ri; io = ii; } } } /* pre-treatment */ if (scale != None) { double ak = 1.0; for (i = 0; i < gdim.rank; i++) ak = ak * ((double)(gdim.dims[i].n)); if (scale == Divide) ak = 1.0 / ak; C2F(dscal)(&lA, &ak, ri, &one); if (isrealA == 0) C2F(dscal)(&lA, &ak, ii, &one); } if (!WITHMKL || gdim.howmany_rank <= 1) { /* Set Plan */ p = GetFFTWPlan(type, &gdim, ri, ii, ro, io, getCurrentFftwFlags(), isn , (fftw_r2r_kind *)NULL,&errflag); if (errflag == 1) { Scierror(999, _("%s: No more memory.\n"), fname); return 0; } else if (errflag == 2) { Scierror(999, _("%s: Creation of requested fftw plan failed.\n"), fname); return 0; } /* execute FFTW plan */ ExecuteFFTWPlan(type, p, ri, ii, ro, io); } else { /*FFTW MKL does not implement yet guru plan with howmany_rank>1 */ /* associated loops described in gdim.howmany_rank and gdim.howmany_dims */ /* are implemented here by a set of call with howmany_rank==1 */ fftw_iodim *howmany_dims = gdim.howmany_dims; int howmany_rank = gdim.howmany_rank; int i1 = 0, i2 = 0; int nloop = 0; int t = 0; gdim.howmany_rank = 0; gdim.howmany_dims = NULL; p = GetFFTWPlan(type, &gdim, ri, ii, ro, io, getCurrentFftwFlags(), isn , (fftw_r2r_kind *)NULL,&errflag); if (errflag == 1) { Scierror(999, _("%s: No more memory.\n"), fname); FREE(dims1); FREE(incr1); return 0; } else if (errflag == 2) { Scierror(999, _("%s: Creation of requested fftw plan failed.\n"), fname); FREE(dims1); FREE(incr1); return 0; } /* flatten nested loops: replace howmany_rank nested loops by a single one*/ /* Build temporary arrays used by flatened loop */ if ((dims1 = (int *)MALLOC(sizeof(int) * howmany_rank)) == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); FREE(dims1); FREE(incr1); return 0; } dims1[0] = howmany_dims[0].n; for (i = 1; i < howmany_rank; i++) dims1[i] = dims1[i - 1] * howmany_dims[i].n; nloop = dims1[howmany_rank - 1]; if ((incr1 = (int *)MALLOC(sizeof(int) * howmany_rank)) == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); FREE(dims1); FREE(incr1); return 0; } t = 1; for (i = 0; i < howmany_rank; i++) { t += (howmany_dims[i].n - 1) * howmany_dims[i].is; incr1[i] = t; } /*loop on each "plan" */ i = 0; /*index on the first plan entry */ for (i1 = 1; i1 <= nloop; i1++) { /* the input and output are assumed to be complex because within MKL real cases are transformed to complex ones in previous steps of sci_fft_gen*/ ExecuteFFTWPlan(type, p, &ri[i], &ii[i], &ro[i], &io[i]); i += howmany_dims[0].is; /* check if a loop ends*/ for (i2 = howmany_rank - 2; i2 >= 0; i2--) { if ((i1 % dims1[i2]) == 0) { /*loop on dimension i2 ends, compute jump on the first plan entry index*/ i += howmany_dims[i2 + 1].is - incr1[i2]; break; } } } /* free temporary arrays */ FREE(dims1); FREE(incr1); /* reset initial value of gdim for post treatment*/ gdim.howmany_rank = howmany_rank; gdim.howmany_dims = howmany_dims; } /* Post treatment */ switch (type) { case R2R_PLAN: if (complete_array(ro, NULL, gdim) == -1) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } break; case C2R_PLAN: break; case R2C_PLAN: if (issymA) { /*R2C has been used to solve an r2r problem*/ if (complete_array(ro, NULL, gdim) == -1) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } } else { if (complete_array(ro, io, gdim) == -1) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } if (isn == FFTW_BACKWARD) { /*conjugate result */ double ak = -1.0; C2F(dscal)(&lA, &ak, io, &one); } } break; case C2C_PLAN: if (WITHMKL && isrealA_save) { if (isn == FFTW_FORWARD) { if (complete_array(ro, io, gdim) == -1) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } } else { if (complete_array(io, ro, gdim) == -1) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 0; } } } break; } return 1; }
/*--------------------------------------------------------------------------*/ 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; }
/*--------------------------------------------------------------------------*/ 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_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_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_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_xpolys(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; int* piAddr3 = NULL; int* l3 = NULL; int m1 = 0, n1 = 0; int m2 = 0, n2 = 0; int m3 = 0, n3 = 0; int i = 0; long hdl = 0; char *pstFigureUID = NULL; char *pstSubWinUID = NULL; char *pstCompoundUID = NULL; int iFalse = 0; int iVisible = 0; int *piVisible = &iVisible; CheckInputArgument(pvApiCtx, 2, 3); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); return 1; } 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; } //CheckSameDims if (m1 != m2 || n1 != n2) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } if (m1 * n1 == 0 || m2 * n2 == 0) { /* dimension 0, 0 polyline to draw */ AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } pstSubWinUID = (char*)getOrCreateDefaultSubwin(); pstFigureUID = (char*)getCurrentFigure(); // Create compound. pstCompoundUID = createGraphicObject(__GO_COMPOUND__); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iFalse, jni_bool, 1); /* Sets the parent-child relationship for the Compound */ setGraphicObjectRelationship(pstSubWinUID, pstCompoundUID); if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr3, &m3, &n3, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); return 1; } //CheckVector if (m3 != 1 && n3 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 3); return 1; } //CheckDimProp if (m3 * n3 < n1) { Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname); return 1; } /* Construct the polylines */ for (i = 0; i < n1; ++i) { Objpoly((l1 + (i * m1)), (l2 + (i * m2)), m1, 0, *(int*)(l3 + i), &hdl); // Add newly created object to Compound setGraphicObjectRelationship(pstCompoundUID, getObjectFromHandle(hdl)); } } else { for (i = 0; i < n1; ++i) { Objpoly((l1 + (i * m1)), (l2 + (i * m2)), m1, 0, 1, &hdl); // Add newly created object to Compound setGraphicObjectRelationship(pstCompoundUID, getObjectFromHandle(hdl)); } } getGraphicObjectProperty(pstFigureUID, __GO_VISIBLE__, jni_bool, (void **)&piVisible); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iVisible, jni_bool, 1); setCurrentObject(pstCompoundUID); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
int hypermatIntExample(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddr = NULL; int iType = 0; int iRet = 0; CheckInputArgument(pvApiCtx, 1, 1); CheckOutputArgument(pvApiCtx, 0, 1); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } if (isEmptyMatrix(pvApiCtx, piAddr)) { iRet = createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1); if (iRet) { return iRet; } AssignOutputVariable(pvApiCtx, 1) = 0; } else if (isHypermatType(pvApiCtx, piAddr)) { int * dims = NULL; int ndims; void * data = NULL; int htype = 0; int precision; sciErr = getHypermatType(pvApiCtx, piAddr, &htype); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } if (htype == sci_ints) { sciErr = getHypermatOfIntegerPrecision(pvApiCtx, piAddr, &precision); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } switch (precision) { case SCI_INT8: sciErr = getHypermatOfInteger8(pvApiCtx, piAddr, &dims, &ndims, (char*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const char*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_UINT8: sciErr = getHypermatOfUnsignedInteger8(pvApiCtx, piAddr, &dims, &ndims, (unsigned char*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const unsigned char*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_INT16: sciErr = getHypermatOfInteger16(pvApiCtx, piAddr, &dims, &ndims, (short*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const short*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_UINT16: sciErr = getHypermatOfUnsignedInteger16(pvApiCtx, piAddr, &dims, &ndims, (unsigned short*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const unsigned short*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_INT32: sciErr = getHypermatOfInteger32(pvApiCtx, piAddr, &dims, &ndims, (int*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const int*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_UINT32: sciErr = getHypermatOfUnsignedInteger32(pvApiCtx, piAddr, &dims, &ndims, (unsigned int*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const unsigned int*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_INT64: sciErr = getHypermatOfInteger64(pvApiCtx, piAddr, &dims, &ndims, (long long*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfInteger64(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const long long*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; case SCI_UINT64: sciErr = getHypermatOfUnsignedInteger64(pvApiCtx, piAddr, &dims, &ndims, (unsigned long long*)&data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } sciErr = createHypermatOfUnsignedInteger64(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, (const unsigned long long*)data); if (sciErr.iErr) { printError(&sciErr, 0); return sciErr.iErr; } break; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: An integer expected.\n"), fname, 1); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; } return 0; }
/*--------------------------------------------------------------------------*/ int sci_param3d1(char *fname, void *pvApiCtx) { SciErr sciErr; int izcol = 0, isfac = 0; double *zcol = NULL; static double ebox_def [6] = { 0, 1, 0, 1, 0, 1}; double *ebox = ebox_def; static int iflag_def[3] = {1, 2, 4}; int iflag[3] , *ifl = NULL; double alpha_def = 35.0 , theta_def = 45.0; double *alpha = &alpha_def, *theta = &theta_def; int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0; int m3n = 0, n3n = 0, m3l = 0; static rhs_opts opts[] = { { -1, "alpha", -1, 0, 0, NULL}, { -1, "ebox", -1, 0, 0, NULL}, { -1, "flag", -1, 0, 0, NULL}, { -1, "leg", -1, 0, 0, NULL}, { -1, "theta", -1, 0, 0, NULL}, { -1, NULL, -1, 0, 0, NULL} }; char * labels = NULL; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int* piAddr31 = NULL; int* piAddr32 = NULL; double* l1 = NULL; double* l2 = NULL; double* l3 = NULL; double* l3n = NULL; if (nbInputArgument(pvApiCtx) <= 0) { sci_demo(fname, pvApiCtx); return 0; } CheckInputArgument(pvApiCtx, 3, 8); if (getOptionals(pvApiCtx, fname, opts) == 0) { ReturnArguments(pvApiCtx); return 0; } if (FirstOpt(pvApiCtx) < 4) { Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4); return (0); } //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, &m1, &n1, &l1); /* x */ if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); printError(&sciErr, 0); return 1; } if (m1 == 1 && n1 > 1) { m1 = n1; n1 = 1; } //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, &m2, &n2, &l2); /* y */ if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2); printError(&sciErr, 0); return 1; } if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1; } if (m1 * n1 == 0) { AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } //CheckSameDims if (m1 != m2 || n1 != n2) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } switch (getInputArgumentType(pvApiCtx, 3)) { case 1 : izcol = 0; // Retrieve a matrix of double at position 3. // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l3". sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3); /* z */ if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } break; case 15 : izcol = 1; /* z = list(z,colors) */ sciErr = getListItemNumber(pvApiCtx, piAddr3, &m3l); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } if (m3l != 2) { Scierror(999, _("%s: Wrong size for input argument #%d: List of size %d expected.\n"), fname, 2, m3l, 2); return 0; } sciErr = getListItemAddress(pvApiCtx, piAddr3, 1, &piAddr31); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getMatrixOfDouble(pvApiCtx, piAddr31, &m3, &n3, &l3); /* z */ if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } sciErr = getListItemAddress(pvApiCtx, piAddr3, 2, &piAddr32); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getMatrixOfDouble(pvApiCtx, piAddr32, &m3n, &n3n, &l3n); /* z */ if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } zcol = (l3n); if (m3n * n3n != n3) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 3, n3); return 0; } break; default : OverLoad(3); return 0; } if (m3 == 1 && n3 > 1) { m3 = n3; n3 = 1; } //CheckSameDims if (m1 != m3 || n1 != n3) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } GetOptionalDoubleArg(pvApiCtx, fname, 4, "theta", &theta, 1, opts); GetOptionalDoubleArg(pvApiCtx, fname, 5, "alpha", &alpha, 1, opts); GetLabels(pvApiCtx, fname, 6, opts, &labels); iflag_def[1] = 8; ifl = &(iflag_def[1]); GetOptionalIntArg(pvApiCtx, fname, 7, "flag", &ifl, 2, opts); iflag[0] = iflag_def[0]; iflag[1] = ifl[0]; iflag[2] = ifl[1]; GetOptionalDoubleArg(pvApiCtx, fname, 8, "ebox", &ebox, 6, opts); if (m1 == 1 && n1 > 1) { m1 = n1; n1 = 1; } getOrCreateDefaultSubwin(); /* NG beg */ isfac = -1; Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), zcol, &m1, &n1, theta, alpha, labels, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04*/ 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; }
int read_integer(char *fname, void* pvApiCtx) { SciErr sciErr; //output variable info int iRows8 = 0; int iCols8 = 0; int iRows16 = 0; int iCols16 = 0; int iRows32 = 0; int iCols32 = 0; int iRowsu8 = 0; int iColsu8 = 0; int iRowsu16 = 0; int iColsu16 = 0; int iRowsu32 = 0; int iColsu32 = 0; int iPrec = 0; int* piAddr8 = NULL; int* piAddr16 = NULL; int* piAddr32 = NULL; int* piAddru8 = NULL; int* piAddru16 = NULL; int* piAddru32 = NULL; char* pcData = NULL; short* psData = NULL; int* piData = NULL; unsigned char* pucData = NULL; unsigned short* pusData = NULL; unsigned int* puiData = NULL; char* pcDataOut = NULL; short* psDataOut = NULL; int* piDataOut = NULL; unsigned char* pucDataOut = NULL; unsigned short* pusDataOut = NULL; unsigned int* puiDataOut = NULL; //check input/output arguments count CheckInputArgument(pvApiCtx, 6, 6); CheckOutputArgument(pvApiCtx, 6, 6); //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //check variable precision sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec); if (sciErr.iErr || iPrec != SCI_INT8) { printError(&sciErr, 0); return 0; } //check variable precision sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec); if (sciErr.iErr || iPrec != SCI_UINT8) { printError(&sciErr, 0); return 0; } //check variable precision sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec); if (sciErr.iErr || iPrec != SCI_INT16) { printError(&sciErr, 0); return 0; } //check variable precision sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec); if (sciErr.iErr || iPrec != SCI_UINT16) { printError(&sciErr, 0); return 0; } //check variable precision sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec); if (sciErr.iErr || iPrec != SCI_INT32) { printError(&sciErr, 0); return 0; } //check variable precision sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec); if (sciErr.iErr || iPrec != SCI_UINT32) { printError(&sciErr, 0); return 0; } //retrieve dimensions and data sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //retrieve dimensions and data sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //retrieve dimensions and data sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //retrieve dimensions and data sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //retrieve dimensions and data sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //retrieve dimensions and data sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //alloc and fill new variable pcDataOut = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData); pucDataOut = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData); psDataOut = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData); pusDataOut = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData); piDataOut = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData); puiDataOut = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData); //create new variable sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //create new variable sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //create new variable sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //create new variable sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //create new variable sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } //create new variable sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } FREE(pcDataOut); FREE(pucDataOut); FREE(psDataOut); FREE(pusDataOut); FREE(piDataOut); FREE(puiDataOut); //assign allocated variables to Lhs position AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3; AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4; AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5; AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6; return 0; }
/*--------------------------------------------------------------------------*/ int sci_x_choice(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrdefaultValuesAdr = NULL; int* piAddrlabelsAdr = NULL; int* piAddrlineLabelsAdr = NULL; double* emptyMatrixAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowDefaultValues = 0, nbColDefaultValues = 0; int nbRowLineLabels = 0, nbColLineLabels = 0; int messageBoxID = 0; char **labelsAdr = NULL; char **lineLabelsAdr = NULL; double *defaultValues = NULL; int *defaultValuesInt = NULL; int userValueSize = 0; int *userValue = NULL; double *userValueDouble = NULL; int K = 0; CheckInputArgument(pvApiCtx, 3, 3); CheckOutputArgument(pvApiCtx, 0, 1); /* READ THE DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValues); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } defaultValuesInt = (int *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(int)); for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++) { defaultValuesInt[K] = (int)defaultValues[K]; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Real or complex vector expected.\n"), fname, 1); return FALSE; } /* READ THE MESSAGE */ if ((checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); FREE(defaultValuesInt); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Choices Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr); /* READ THE LABELS */ if (checkInputArgumentType(pvApiCtx, 3, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlineLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if (nbRow != 1 && nbCol != 1) { freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels); freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } /* Default selected buttons */ setMessageBoxDefaultSelectedButtons(messageBoxID, defaultValuesInt, nbRowDefaultValues * nbColDefaultValues); /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0; nbCol = 0; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else { userValue = (int*)getMessageBoxUserSelectedButtons(messageBoxID); userValueDouble = (double *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(double)); for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++) { userValueDouble[K] = userValue[K]; } sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValueDouble); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } /* TO DO : do a delete [] getMessageBoxUserSelectedButtons */ } FREE(defaultValuesInt); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_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 sci_xtitle(char * fname, unsigned long fname_len) { SciErr sciErr; int* piAddr4 = NULL; int* boxPtr = NULL; int* piAddrStr = NULL; int narg = 0; int nbLabels = 0; /* number of modified labels */ int box = 0; BOOL isBoxSpecified = FALSE; int iSubwinUID = 0; static rhs_opts opts[] = { { -1, "boxed", -1, 0, 0, NULL}, { -1, NULL, -1, 0, 0, NULL} }; if (nbInputArgument(pvApiCtx) <= 0) { sci_demo(fname, fname_len); return 0; } CheckInputArgument(pvApiCtx, 1, 5); nbLabels = nbInputArgument(pvApiCtx); /* get the given options from the name in opts */ if (!getOptionals(pvApiCtx, fname, opts)) { /* error */ return 0; } /* compatibility with previous version in which box was put */ /* at the fourth position */ if (nbInputArgument(pvApiCtx) == 4) { int type = getInputArgumentType(pvApiCtx, 4); if (type == 1 || type == 8)/* double or int */ { int n = 0, m = 0; sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr4, &m, &n, &boxPtr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4); return 1; } //CheckScalar if (m != 1 || n != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4); return 1; } box = *boxPtr; nbLabels--; /* it is not a label text */ isBoxSpecified = TRUE; } } if (opts[0].iPos != -1 && !isBoxSpecified) { /* check if "box" is in the options */ getScalarBoolean(pvApiCtx, opts[0].piAddr, &box); if (opts[0].iRows != 1 || opts[0].iCols != 1) { /* check size */ Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname); return 1; } nbLabels--; /* it is not a label text */ } iSubwinUID = getOrCreateDefaultSubwin(); for (narg = 1 ; narg <= nbLabels ; narg++) { int m = 0, n = 0; char **Str = NULL; int iModifiedLabel = 0; int* piModifiedLabel = &iModifiedLabel; sciErr = getVarAddressFromPosition(pvApiCtx, narg, &piAddrStr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position narg. if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m, &n, &Str)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, narg); return 1; } if (m * n == 0) { continue; } switch (narg) { case 1: getGraphicObjectProperty(iSubwinUID, __GO_TITLE__, jni_int, (void **)&piModifiedLabel); break; case 2: getGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel); break; case 3: getGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel); break; case 4: getGraphicObjectProperty(iSubwinUID, __GO_Z_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel); break; default: break; } #if 0 startFigureDataWriting(pFigure); #endif sciSetText(iModifiedLabel, Str, m, n); setGraphicObjectProperty(iModifiedLabel, __GO_FILL_MODE__, &box, jni_bool, 1); #if 0 endFigureDataWriting(pFigure); #endif freeArrayOfString(Str, m * n); } setCurrentObject(iSubwinUID); #if 0 sciDrawObj(pFigure); #endif AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
int sci_listvar_in_hdf5_v1(char *fname, int* pvCtx) { SciErr sciErr; int *piAddr = NULL; char* pstFile = NULL; int iFile = 0; int iNbItem = 0; VarInfo_v1* pInfo = NULL; CheckInputArgument(pvCtx, 1, 1); CheckOutputArgument(pvCtx, 1, 4); sciErr = getVarAddressFromPosition(pvCtx, 1, &piAddr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (getAllocatedSingleString(pvCtx, piAddr, &pstFile)) { if (pstFile) { FREE(pstFile); } Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1); return 1; } char* pstFileName = expandPathVariable(pstFile); iFile = openHDF5File(pstFileName, 0); if (iFile < 0) { FREE(pstFileName); Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile); FREE(pstFile); return 1; } FREE(pstFileName); FREE(pstFile); iNbItem = getVariableNames_v1(iFile, NULL); if (iNbItem != 0) { char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem); bool b; pInfo = (VarInfo_v1*)MALLOC(iNbItem * sizeof(VarInfo_v1)); if (nbOutputArgument(pvCtx) == 1) { sciprint("Name Type Size Bytes\n"); sciprint("---------------------------------------------------------------\n"); } iNbItem = getVariableNames_v1(iFile, pstVarNameList); for (int i = 0; i < iNbItem; i++) { int iDataSetId = getDataSetIdFromName_v1(iFile, pstVarNameList[i]); if (iDataSetId == 0) { break; } strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName)); b = read_data_v1(pvCtx, iDataSetId, 0, NULL, &pInfo[i]) == false; closeDataSet_v1(iDataSetId); if (b) { break; } if (nbOutputArgument(pvCtx) == 1) { sciprint("%s\n", pInfo[i].pstInfo); } } freeArrayOfString(pstVarNameList, iNbItem); } else { //no variable returms [] for each Lhs for (int i = 0 ; i < nbOutputArgument(pvCtx) ; i++) { createEmptyMatrix(pvCtx, nbInputArgument(pvCtx) + i + 1); AssignOutputVariable(pvCtx, i + 1) = nbInputArgument(pvCtx) + i + 1; } ReturnArguments(pvCtx); return 0; } closeHDF5File(iFile); //1st Lhs char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem); for (int i = 0 ; i < iNbItem ; i++) { pstVarName[i] = pInfo[i].varName; } sciErr = createMatrixOfString(pvCtx, nbInputArgument(pvCtx) + 1, iNbItem, 1, pstVarName); FREE(pstVarName); if (sciErr.iErr) { FREE(pInfo); printError(&sciErr, 0); return 1; } AssignOutputVariable(pvCtx, 1) = nbInputArgument(pvCtx) + 1; if (nbOutputArgument(pvCtx) > 1) { //2nd Lhs double* pdblType; sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 2, iNbItem, 1, &pdblType); if (sciErr.iErr) { FREE(pInfo); printError(&sciErr, 0); return 1; } for (int i = 0 ; i < iNbItem ; i++) { pdblType[i] = pInfo[i].iType; } AssignOutputVariable(pvCtx, 2) = nbInputArgument(pvCtx) + 2; if (nbOutputArgument(pvCtx) > 2) { //3rd Lhs int* pList = NULL; sciErr = createList(pvCtx, nbInputArgument(pvCtx) + 3, iNbItem, &pList); for (int i = 0 ; i < iNbItem ; i++) { double* pdblDims = NULL; allocMatrixOfDoubleInList(pvCtx, nbInputArgument(pvCtx) + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims); for (int j = 0 ; j < pInfo[i].iDims ; j++) { pdblDims[j] = pInfo[i].piDims[j]; } } AssignOutputVariable(pvCtx, 3) = nbInputArgument(pvCtx) + 3; } if (nbOutputArgument(pvCtx) > 3) { //4th Lhs double* pdblSize; sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 4, iNbItem, 1, &pdblSize); for (int i = 0 ; i < iNbItem ; i++) { pdblSize[i] = pInfo[i].iSize; } AssignOutputVariable(pvCtx, 4) = nbInputArgument(pvCtx) + 4; } } FREE(pInfo); ReturnArguments(pvCtx); 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_xrects(char *fname, void *pvApiCtx) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddr2 = NULL; int* l2 = NULL; int m1 = 0, n1 = 0, m2 = 0, n2 = 0; long hdl = 0; int i = 0; int iSubwinUID = 0; int foreground = 0; int *piForeground = &foreground; int iCompoundUID = 0; CheckInputArgument(pvApiCtx, 1, 2); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } if (m1 != 4) { Scierror(999, _("%s: Wrong size for input argument #%d: %s expected.\n"), fname, 1, "(4,n)"); return 0; } if (nbInputArgument(pvApiCtx) == 2) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr2, &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; } //CheckVector if (m2 != 1 && n2 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2); return 1; } if (m2 * n2 != n1) { Scierror(999, _("%s: Incompatible length for input arguments #%d and #%d.\n"), fname, 1, 2); return 0; } } else { m2 = 1; n2 = n1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 2, m2, n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (i = 0; i < n2; ++i) { l2[i] = 0; } } iSubwinUID = getOrCreateDefaultSubwin(); // Create compound. iCompoundUID = createGraphicObject(__GO_COMPOUND__); /* Sets the parent-child relationship for the Compound */ setGraphicObjectRelationship(iSubwinUID, iCompoundUID); /** Get Subwin line color */ getGraphicObjectProperty(iSubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeground); for (i = 0; i < n1; ++i) { /* j = (i==0) ? 0 : 1; */ if (l2[i] == 0) { /** fil(i) = 0 rectangle i is drawn using the current line style (or color).**/ /* color setting is done now */ Objrect((l1 + (4 * i)), (l1 + (4 * i) + 1), (l1 + (4 * i) + 2), (l1 + (4 * i) + 3), &foreground, NULL, FALSE, TRUE, &hdl); } else { if (l2[i] < 0) { /** fil(i) < 0 rectangle i is drawn using the line style (or color) **/ int tmp = - (*(int*)(l2 + i)); Objrect((l1 + (4 * i)), (l1 + (4 * i) + 1), (l1 + (4 * i) + 2), (l1 + (4 * i) + 3), &tmp, NULL, FALSE, TRUE, &hdl); } else { /** fil(i) > 0 rectangle i is filled using the pattern (or color) **/ Objrect((l1 + (4 * i)), (l1 + (4 * i) + 1), (l1 + (4 * i) + 2), (l1 + (4 * i) + 3), NULL, l2 + i, TRUE, FALSE, &hdl); } } // Add newly created object to Compound setGraphicObjectRelationship(iCompoundUID, getObjectFromHandle(hdl)); } /** make Compound current object **/ setCurrentObject(iCompoundUID); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ 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; }
/* Return text of fftw wisdom * * Scilab Calling sequence : * -->tt=get_fftw_wisdom(); * * Input : Nothing * * Output : a scilab string matrix * */ int sci_get_fftw_wisdom(char *fname, void* pvApiCtx) { int n1 = 0, i = 0, j = 0; char *Str = NULL; char **Str1 = NULL; CheckInputArgument(pvApiCtx, 0, 0); CheckOutputArgument(pvApiCtx, 0, 1); if ((Str = call_fftw_export_wisdom_to_string()) == NULL) { Scierror(999, _("%s: MKL fftw library does not implement wisdom functions yet.\n"), fname); return 1; } n1 = 0; j = 0; if (Str) { int lenStr = (int)strlen(Str); for (i = 0; i < lenStr; i++) { if (Str[i] == '\n') { int len = 0; int k = 0; n1++; if (Str1) { Str1 = (char **)REALLOC(Str1, sizeof(char *) * n1); } else { Str1 = (char **)MALLOC(sizeof(char *) * n1); } if (Str1 == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); if (Str) { // According to the FFTW documentation we should free Str // string but doing makes Scilab crash!? //free(Str); } return 1; } len = i - j; if ((Str1[n1 - 1] = (char *)MALLOC(sizeof(char) * (len + 1))) == NULL) { freeArrayOfString(Str1, n1 - 1); if (Str) { // According to the FFTW documentation we should free Str // string but doing makes Scilab crash!? //free(Str); } Scierror(999, _("%s: No more memory.\n"), fname); return 1; } for (k = 0; k < len; k++) { Str1[n1 - 1][k] = Str[k + j]; } Str1[n1 - 1][len] = '\0'; j = i + 1; } } } n1++; if (Str1) { Str1 = (char **)REALLOC(Str1, sizeof(char *) * n1); } else { Str1 = (char **)MALLOC(sizeof(char *) * n1); } if (Str1 == NULL) { Scierror(999, _("%s: No more memory.\n"), fname); if (Str) { // According to the FFTW documentation we should free Str // string but doing makes Scilab crash!? //free(Str); } return 1; } if ((Str1[n1 - 1] = (char *)MALLOC(sizeof(char))) == NULL) { freeArrayOfString(Str1, n1 - 1); if (Str) { // According to the FFTW documentation we should free Str // string but doing makes Scilab crash!? //free(Str); } Scierror(999, _("%s: No more memory.\n"), fname); return 1; } Str1[n1 - 1][0] = '\0'; createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, n1, 1, Str1); freeArrayOfString(Str1, n1); if (Str) { // According to the FFTW documentation we should free Str // string but doing makes Scilab crash!? //free(Str); } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_glue(char * fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; long long* l1 = NULL; double* l2 = NULL; int* lind = NULL; long long* outindex = NULL; int numrow = 0, numcol = 0, n = 0, cx1 = 1; int *pObj = NULL; int i = 0; int iCompoundUID = 0; int iParentUID = 0; int iCurrentParentUID = 0; int* piCurrentParentUID = &iCurrentParentUID; int iObjUID = 0; CheckInputArgument(pvApiCtx, 1, 1); CheckOutputArgument(pvApiCtx, 0, 1); /* set or create a graphic window */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of handle at position 1. sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &numrow, &numcol, &l1); /* We get the scalar value if it is ones */ if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1); return 1; } n = numrow * numcol; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 2, numrow, numcol, &lind); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } if (n > 1) { C2F(dcopy)(&n, (double*)l1, &cx1, l2, &cx1); C2F(dsort)(l2, &n, (int*)(lind)); for (i = 1; i < n; i++) { long long i1 = ((long long*)l2)[i]; long long i2 = ((long long*)l2)[i - 1]; if (i1 == i2) { Scierror(999, _("%s: Each handle should not appear twice.\n"), fname); return 0; } } } /* we must change the pobj to the Compound type */ pObj = (int*)MALLOC(n * sizeof(int)); for (i = 0 ; i < n ; i++) { iObjUID = getObjectFromHandle((long)l1[i]); pObj[i] = iObjUID; if (iObjUID == 0) { FREE(pObj); Scierror(999, _("%s: The handle is not or no more valid.\n"), fname); return 0; } iCurrentParentUID = getParentObject(iObjUID); //getGraphicObjectProperty(iObjUID, __GO_PARENT__, jni_string, (void **)&piCurrentParentUID); if (i == 0) { iParentUID = iCurrentParentUID; } if (iParentUID != iCurrentParentUID) { FREE(pObj); Scierror(999, _("%s: Objects must have the same parent.\n"), fname); return 0; } } //ret = CheckForCompound (handelsvalue, n); //if (ret>0) //{ // MEM LEAK // Scierror(999,_("%s: Handle %d cannot be glued (invalid parent).\n"),fname,ret); // return 0; //} //if (ret<0) //{ // MEM LEAK // Scierror(999,_("%s: Handle %d cannot be glued (invalid type).\n"),fname,-ret); // return 0; //} iCompoundUID = createCompound(iParentUID, pObj, n); setCurrentObject(iCompoundUID); numrow = 1; numcol = 1; sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 3, numrow, numcol, &outindex); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } outindex[0] = getHandle(iCompoundUID); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 3; ReturnArguments(pvApiCtx); FREE(pObj); return 0; }