int get_list_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos) { SciErr sciErr; int i; int iRet = 0; int iItem = 0; int* piChild = NULL; sciErr = getListItemNumber(_pvCtx, _piAddr, &iItem); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciprint("(%d)\n", iItem); for (i = 0 ; i < iItem ; i++) { sciErr = getListItemAddress(_pvCtx, _piAddr, i + 1, &piChild); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } iTab++; iRet = get_info(_pvCtx, _iRhs, _piAddr, piChild, i + 1); iTab--; } return 0;; }
/*--------------------------------------------------------------------------*/ int checkPList(void* _pvCtx, int * _piAddress) { int nb_param = 0, i = 0, var_type = 0; int m_label = 0, n_label = 0; int * len_label = NULL; char ** label_list = NULL; int result = 0; SciErr _SciErr; _SciErr.iErr = 0; _SciErr.iMsgCount = 0; _SciErr = getVarType(_pvCtx, _piAddress, &var_type); if (var_type != sci_mlist) { return 0; } _SciErr = getListItemNumber(_pvCtx, _piAddress, &nb_param); if (nb_param != 0) { _SciErr = getMatrixOfStringInList(_pvCtx, _piAddress, 1, &m_label, &n_label, NULL, NULL); len_label = (int *)MALLOC(m_label * n_label * sizeof(int)); _SciErr = getMatrixOfStringInList(_pvCtx, _piAddress, 1, &m_label, &n_label, len_label, NULL); label_list = (char **)MALLOC(m_label * n_label * sizeof(char *)); for (i = 0; i < n_label * m_label; i++) { label_list[i] = (char *)MALLOC((len_label[i] + 1) * sizeof(char)); } _SciErr = getMatrixOfStringInList(_pvCtx, _piAddress, 1, &m_label, &n_label, len_label, label_list); if (strcmp(label_list[0], "plist") != 0) { if (len_label) { FREE(len_label); len_label = NULL; } freeArrayOfString(label_list, m_label * n_label); return 0; } if (len_label) { FREE(len_label); len_label = NULL; } freeArrayOfString(label_list, m_label * n_label); } result = 1; return result; }
static bool export_list(int _iH5File, int *_piVar, char* _pstName, int _iVarType) { int iRet = 0; bool bReturn = false; int iItemNumber = 0; SciErr sciErr = getListItemNumber(pvApiCtx, _piVar, &iItemNumber); if (sciErr.iErr) { printError(&sciErr, 0); return false; } //create groupe name char* pstGroupName = createGroupName(_pstName); char pstMsg[256]; sprintf(pstMsg, "list (%d)", iItemNumber); print_type(pstMsg); iLevel++; //open list void *pvList = openList(_iH5File, pstGroupName, iItemNumber); for (int i = 0 ; i < iItemNumber ; i++) { int *piNewVar = NULL; getListItemAddress(pvApiCtx, _piVar, i + 1, &piNewVar);//1 indexed char* pstPathName = createPathName(pstGroupName, i); if (piNewVar == NULL) { //undefined item bReturn = export_undefined(_iH5File, piNewVar, pstPathName); } else { bReturn = export_data(_iH5File, piNewVar, pstPathName); } iRet = addItemInList(_iH5File, pvList, i, pstPathName); FREE(pstPathName); if (bReturn == false || iRet) { return false; } } iLevel--; closeList(_iH5File, pvList, _pstName, iItemNumber, _iVarType); FREE(pstGroupName); //close list return true; }
/* ========================================================================== */ int sci_gpuApplyFunction(char *fname) { SciErr sciErr; int block_w = 0, block_h = 0, grid_w = 0, grid_h = 0; int row = 0, col = 0; int argnum = 0; int retnumbvalue = 0; double* MM = NULL; int *ptr = NULL; int *lstptr = NULL; int *dptr[4]; int inputType_1 = 0; int inputType_2 = 0; CheckRhs(6, 6); CheckLhs(1, 1); try { void *fptr = NULL; if (!isGpuInit()) { throw "gpu is not initialised. Please launch gpuInit() before use this function."; } sciErr = getVarAddressFromPosition(pvApiCtx, 1, &ptr); if (sciErr.iErr) { throw sciErr; } sciErr = getVarType(pvApiCtx, ptr, &inputType_1); if (sciErr.iErr) { throw sciErr; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &lstptr); if (sciErr.iErr) { throw sciErr; } sciErr = getVarType(pvApiCtx, lstptr, &inputType_2); if (sciErr.iErr) { throw sciErr; } if (inputType_1 != sci_pointer) { throw "gpuApplyFuntion : Bad type for input argument #1: A string expected."; } else if (inputType_2 != sci_list) { throw "gpuApplyFuntion : Bad type for input argument #2: A list expected."; } else { for (int i = 3; i < 7; i++) { int inputType = 0; sciErr = getVarAddressFromPosition(pvApiCtx, i, &dptr[i - 3]); if (sciErr.iErr) { throw sciErr; } sciErr = getVarType(pvApiCtx, dptr[i - 3], &inputType); if (sciErr.iErr) { throw sciErr; } if (inputType != sci_matrix) { char string[64]; sprintf(string, "gpuApplyFunction : Bad type for input argument #%d : A matrix expected.", i); throw string; } } sciErr = getPointer(pvApiCtx, ptr, (void**)&fptr); if (sciErr.iErr) { throw sciErr; } sciErr = getListItemNumber(pvApiCtx, lstptr, &argnum); if (sciErr.iErr) { throw sciErr; } sciErr = getMatrixOfDouble(pvApiCtx, dptr[0], &row, &col, &MM); if (sciErr.iErr) { throw sciErr; } if (row * col != 1) { throw "gpuApplyFunction : Bad size for input argument #3: A scalar expected."; } block_h = (int)MM[0]; sciErr = getMatrixOfDouble(pvApiCtx, dptr[1], &row, &col, &MM); if (sciErr.iErr) { throw sciErr; } if (row * col != 1) { throw "gpuApplyFunction : Bad size for input argument #4: A scalar expected."; } block_w = (int)MM[0]; sciErr = getMatrixOfDouble(pvApiCtx, dptr[2], &row, &col, &MM); if (sciErr.iErr) { throw sciErr; } if (row * col != 1) { throw "gpuApplyFunction : Bad size for input argument #5: A scalar expected."; } grid_h = (int)MM[0]; sciErr = getMatrixOfDouble(pvApiCtx, dptr[3], &row, &col, &MM); if (sciErr.iErr) { throw sciErr; } if (row * col != 1) { throw "gpuApplyFunction : Bad size for input argument #6: A scalar expected."; } grid_w = (int)MM[0]; #ifdef WITH_CUDA if (useCuda()) { Kernel<ModeDefinition<CUDA> >* fptrCuda = (Kernel<ModeDefinition<CUDA> >*)fptr; sci_CUDA_getArgs(fptrCuda, lstptr, argnum, fname); fptrCuda->launch(getCudaQueue() , block_w, block_h, grid_w, grid_h); } #endif #ifdef WITH_OPENCL if (!useCuda()) { Kernel<ModeDefinition<OpenCL> >* fptrOpenCL = (Kernel<ModeDefinition<OpenCL> >*)fptr; sci_OpenCL_getArgs(fptrOpenCL, lstptr, argnum, fname); fptrOpenCL->launch(getOpenClQueue(), block_w, block_h, grid_w * block_w, grid_h * block_h); } #endif PutLhsVar(); } } catch (const char* str) { Scierror(999, "%s: %s\n", fname, str); } catch (SciErr E) { printError(&E, 0); } 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 ScilabGateway::invoke_lu(char * fname, const int envId, void * pvApiCtx) { SciErr err; int typ = 0; int * addr = 0; int * listaddr = 0; int len = 0; int * tmpvar = 0; int idObj = 0; int * args = 0; int * child = 0; char * methName = 0; int * eId; int row, col; int * ret = 0; int nbArgs = 0; std::vector<int> torem; CheckInputArgument(pvApiCtx, 4, 4); err = getVarAddressFromPosition(pvApiCtx, 4, &listaddr); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } err = getVarType(pvApiCtx, listaddr, &typ); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } if (typ != sci_list) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A List expected."), 4); } err = getListItemNumber(pvApiCtx, listaddr, &len); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } // Get the environment id err = getVarAddressFromPosition(pvApiCtx, 2, &addr); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } err = getVarType(pvApiCtx, addr, &typ); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } if (typ != sci_ints) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 2); } else { int prec; err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } if (prec != SCI_INT32) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 2); } err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &eId); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } } ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(*eId); ScilabGatewayOptions & options = env.getGatewayOptions(); OptionsHelper::setCopyOccurred(false); ScilabObjects::initialization(env, pvApiCtx); options.setIsNew(false); // Get the object id err = getVarAddressFromPosition(pvApiCtx, 1, &addr); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } err = getVarType(pvApiCtx, addr, &typ); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } if (typ != sci_ints) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 1); } else { int prec; int * id; err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } if (prec != SCI_INT32) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 1); } err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &id); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } idObj = *id; } if (idObj == 0) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot invoke on null object."), __FILE__, __LINE__); } tmpvar = new int[len + 1]; *tmpvar = 0; args = new int[len]; nbArgs = len; for (int i = 0; i < len; i++) { err = getListItemAddress(pvApiCtx, listaddr, i + 1, &child); if (err.iErr) { delete[] args; ScilabObjects::removeTemporaryVars(*eId, tmpvar); delete[] tmpvar; throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } try { args[i] = ScilabObjects::getArgumentId(child, tmpvar, false, false, *eId, pvApiCtx); } catch (ScilabAbstractEnvironmentException & e) { delete[] args; delete[] tmpvar; throw; } if (args[i] == VOID_OBJECT) { nbArgs = 0; } } try { methName = ScilabObjects::getSingleString(3, pvApiCtx); } catch (ScilabAbstractEnvironmentException & e) { delete[] args; ScilabObjects::removeTemporaryVars(*eId, tmpvar); delete[] tmpvar; throw; } try { ret = env.invoke(idObj, methName, args, nbArgs); } catch (std::exception & e) { delete[] args; ScilabObjects::removeTemporaryVars(*eId, tmpvar); delete[] tmpvar; freeAllocatedSingleString(methName); throw; } delete[] args; ScilabObjects::removeTemporaryVars(*eId, tmpvar); delete[] tmpvar; freeAllocatedSingleString(methName); if (!ret || *ret <= 0 || (*ret == 1 && ret[1] == VOID_OBJECT)) { if (ret) { delete[] ret; } PutLhsVar(); return 0; } torem.reserve(*ret); for (int i = 1; i <= *ret; i++) { if (!ScilabObjects::unwrap(ret[i], Rhs + i, *eId, pvApiCtx)) { try { ScilabObjects::createEnvironmentObjectAtPos(EXTERNAL_OBJECT, Rhs + i, ret[i], *eId, pvApiCtx); } catch (ScilabAbstractEnvironmentException & e) { if (!torem.empty()) { env.removeobject(&(torem[0]), torem.size()); } env.removeobject(ret + 1, *ret); delete[] ret; throw; } } else { torem.push_back(ret[i]); } LhsVar(i) = Rhs + i; } if (!torem.empty()) { env.removeobject(&(torem[0]), torem.size()); } delete[] ret; PutLhsVar(); 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; }
/*--------------------------------------------------------------------------*/ int sci_plot3d(char * fname, unsigned long fname_len) { SciErr sciErr; static double ebox_def [6] = { 0, 1, 0, 1, 0, 1}; double *ebox = ebox_def; static int iflag_def[3] = {2, 2, 4}; int *iflag = iflag_def; 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; int izcol = 0, isfac = 0; double *zcol = NULL; 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 * legend = 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; /* ** This overload the function to call demo script ** the demo script is called %_<fname> */ if (nbInputArgument(pvApiCtx) <= 0) { sci_demo(fname, fname_len); return 0; } CheckInputArgument(pvApiCtx, 3, 8); if (getOptionals(pvApiCtx, fname, opts) == 0) { ReturnArguments(pvApiCtx); return 0; } if (FirstOpt() < 4) { Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4); return -1; } //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); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); printError(&sciErr, 0); return 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); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2); printError(&sciErr, 0); return 1; } if (m1 * n1 == 0) { AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } if (nbInputArgument(pvApiCtx) >= 3) { /* third argument can be a matrix z or a list list(z,zcol) */ sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } switch (getInputArgumentType(pvApiCtx, 3)) { case sci_matrix : //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } izcol = 0; break; case sci_list : 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 1; } 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 && m3n * n3n != m3 * n3) { Scierror(999, _("%s: Wrong size for input argument #%d: %d or %d expected.\n"), fname, 3, n3, m3 * n3); return 1; } /* * Added by E Segre 4/5/2000. In the case where zcol is a * matrix of the same size as z, we set izcol to 2. This * value is later transmitted to the C2F(fac3dg) routine, * which has been modified to do the interpolated shading * (see the file SCI/modules/graphics/src/c/Plo3d.c */ if (m3n * n3n == m3 * n3) { izcol = 2 ; } break; default : OverLoad(3); return 0; } } iflag_def[1] = 8; GetOptionalDoubleArg(pvApiCtx, fname, 4, "theta", &theta, 1, opts); GetOptionalDoubleArg(pvApiCtx, fname, 5, "alpha", &alpha, 1, opts); GetLabels(pvApiCtx, fname, 6, opts, &legend); GetOptionalIntArg(pvApiCtx, fname, 7, "flag", &iflag, 3, opts); GetOptionalDoubleArg(pvApiCtx, fname, 8, "ebox", &ebox, 6, opts); if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) { if (! (m1 == m2 && m2 == m3 && n1 == n2 && n2 == n3)) { Scierror(999, _("%s: Wrong value for input arguments #%d, #%d and #%d: Incompatible length.\n"), fname, 1, 2, 3); return 1; } } else { if (m2 * n2 != n3) { Scierror(999, _("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"), fname, 2, 3); return 1; } if (m1 * n1 != m3) { Scierror(999, _("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"), fname, 1, 3); return 1; } if (m1 * n1 <= 1 || m2 * n2 <= 1) { Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: %s expected.\n"), fname, 2, 3, ">= 2"); return 1; } } if (m1 * n1 == 0 || m2 * n2 == 0 || m3 * n3 == 0) { AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } getOrCreateDefaultSubwin(); /******************** 24/05/2002 ********************/ if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) /* NG beg */ { isfac = 1; } else { isfac = 0; } Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), zcol, &m3, &n3, theta, alpha, legend, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04 and 19.03.04*/ AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*-------------------------------------------------------------------------- * sciset(choice-name,x1,x2,x3,x4,x5) * or xset() *-----------------------------------------------------------*/ int sci_set(char *fname, void *pvApiCtx) { SciErr sciErr; int i = 0; int* piAddr1 = NULL; int isMatrixOfString = 0; char* pstNewProperty = NULL; unsigned long hdl; int iObjUID = 0; int iType = 0; int* piType = &iType; int iSetProperty = 0; int iRhs = nbInputArgument(pvApiCtx); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1); return 1; } if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1)) { OverLoad(1); return 0; } CheckInputArgumentAtLeast(pvApiCtx, 2); CheckOutputArgument(pvApiCtx, 0, 1); if (isDoubleType(pvApiCtx, piAddr1)) /* tclsci handle */ { /* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */ OverLoad(1); return 0; } if (iRhs == 2) { #define NB_PROPERTIES_SUPPORTED 7 /* No object specified */ /* ONLY supported properties are */ /* 'current_entity' */ /* 'hdl' */ /* 'current_figure' */ /* 'current_axes' */ /* 'default_values' */ /* 'figure_style' for compatibility but do nothing */ /* others values must return a error */ char *propertiesSupported[NB_PROPERTIES_SUPPORTED] = { "current_entity", "hdl", "current_figure", "current_axes", "figure_style", "default_values", "auto_clear" }; int iPropertyFound = 0; int* piAddr2 = NULL; int iType2 = 0; int iRows2 = 0; int iCols2 = 0; void* pvData = NULL; char* pstProperty = NULL; if (isStringType(pvApiCtx, piAddr1) == 0) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 1); return 0; } if (getAllocatedSingleString(pvApiCtx, piAddr1, &pstProperty)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 1); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2); return 1; } sciErr = getVarType(pvApiCtx, piAddr2, &iType2); if (sciErr.iErr) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2); return 1; } switch (iType2) { case sci_matrix: sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows2, &iCols2, (double**)&pvData); if (sciErr.iErr) { freeAllocatedSingleString(pstProperty); printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: Matrix expected.\n"), fname, 2); return sciErr.iErr; } break; case sci_handles : sciErr = getMatrixOfHandle(pvApiCtx, piAddr2, &iRows2, &iCols2, (long long**)&pvData); if (sciErr.iErr) { freeAllocatedSingleString(pstProperty); printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of handle expected.\n"), fname, 3); return 1; } break; case sci_strings : if (strcmp(pstProperty, "tics_labels") == 0 || strcmp(pstProperty, "auto_ticks") == 0 || strcmp(pstProperty, "axes_visible") == 0 || strcmp(pstProperty, "axes_reverse") == 0 || strcmp(pstProperty, "text") == 0 || strcmp(pstProperty, "ticks_format") == 0) { isMatrixOfString = 1; if (getAllocatedMatrixOfString(pvApiCtx, piAddr2, &iRows2, &iCols2, (char***)&pvData)) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Wrong size for input argument #%d: A matrix of string expected.\n"), fname, 2); return 1; } } else { if (getAllocatedSingleString(pvApiCtx, piAddr2, (char**)&pvData)) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 2); return 1; } iRows2 = (int)strlen((char*)pvData); iCols2 = 1; isMatrixOfString = 0; } break; } for (i = 0; i < NB_PROPERTIES_SUPPORTED; i++) { if (strcmp(propertiesSupported[i], pstProperty) == 0) { iPropertyFound = 1; } } if (iPropertyFound) { callSetProperty(pvApiCtx, 0, pvData, iType2, iRows2, iCols2, pstProperty); if (iType2 == sci_strings) { //free allocated data if (isMatrixOfString == 1) { freeAllocatedMatrixOfString(iRows2, iCols2, (char**)pvData); } else { freeAllocatedSingleString((char*)pvData); } } } else { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Wrong value for input argument #%d: a valid property expected.\n"), fname, 1); if (iType2 == sci_strings) { if (isMatrixOfString == 1) { freeAllocatedMatrixOfString(iRows2, iCols2, (char**)pvData); } else { freeAllocatedSingleString((char*)pvData); } } return 0; } freeAllocatedSingleString(pstProperty); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } if (iRhs % 2 != 1) { Scierror(999, _("%s: Wrong number of input argument(s) : an odd number is expected.\n"), fname); return 0; } /* after the call to sciSet get the status : 0 <=> OK, */ /* -1 <=> Error, */ /* 1 <=> nothing done */ /* set or create a graphic window */ if (isHandleType(pvApiCtx, piAddr1) == 0 && isStringType(pvApiCtx, piAddr1) == 0) { Scierror(999, _("%s: Wrong type for input argument #%d: A handle or a string expected.\n"), fname, 1); return 0; } if (isStringType(pvApiCtx, piAddr1)) { char* pstPath = NULL; if (getAllocatedSingleString(pvApiCtx, piAddr1, &pstPath)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 1); return 1; } iObjUID = search_path(pstPath); if (iObjUID == 0) { Scierror(999, _("%s: Unable to find handle for path %s.\n"), fname, pstPath); freeAllocatedSingleString(pstPath); return 1; } } else { //matrix of handle are managed by a %h_set if (isScalar(pvApiCtx, piAddr1) == FALSE) { OverLoad(1); return 0; } if (getScalarHandle(pvApiCtx, piAddr1, (long long*)&hdl)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single handle expected.\n"), fname, 1); return 1; } iObjUID = getObjectFromHandle(hdl); } if (iObjUID == 0) { Scierror(999, _("%s: The handle is not or no more valid.\n"), fname); return 0; } for (i = 1 ; i < iRhs ; i = i + 2) { int setStatus = 0; int* piAddr2 = NULL; int* piAddr3 = NULL; int iPos = i + 1; int isData = 0; int iRows3 = 0; int iCols3 = 0; int iType3 = 0; void* pvData = NULL; char* pstProperty = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, iPos, &piAddr2); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos); return 1; } if (isStringType(pvApiCtx, piAddr2) == 0) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, iPos); return 0; } if (getAllocatedSingleString(pvApiCtx, piAddr2, &pstProperty)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, iPos); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, iPos + 1, &piAddr3); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1); return 1; } if ((pstProperty[0] == 'd' || pstProperty[0] == 'D') && stricmp("data", pstProperty) == 0) { //send to datamodel isData = 1; } if (stricmp(pstProperty, "user_data") == 0 || stricmp(pstProperty, "userdata") == 0 || stricmp(pstProperty, "display_function_data") == 0 || stricmp(pstProperty, "data") == 0) { /* in this case set_user_data_property * directly uses the third position in the stack * to get the variable which is to be set in * the user_data property (any data type is allowed) S. Steer */ pvData = (void*)piAddr3; /*position in the stack */ iRows3 = -1; /*unused */ iCols3 = -1; /*unused */ iType3 = -1; } else { sciErr = getVarType(pvApiCtx, piAddr3, &iType3); if (sciErr.iErr) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1); return 1; } switch (iType3) { case sci_matrix : sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows3, &iCols3, (double**)&pvData); break; case sci_boolean : sciErr = getMatrixOfBoolean(pvApiCtx, piAddr3, &iRows3, &iCols3, (int**)&pvData); break; case sci_handles : sciErr = getMatrixOfHandle(pvApiCtx, piAddr3, &iRows3, &iCols3, (long long**)&pvData); break; case sci_strings : if (strcmp(pstProperty, "tics_labels") != 0 && strcmp(pstProperty, "auto_ticks") != 0 && strcmp(pstProperty, "tight_limits") != 0 && strcmp(pstProperty, "axes_visible") != 0 && strcmp(pstProperty, "axes_reverse") != 0 && strcmp(pstProperty, "text") != 0 && stricmp(pstProperty, "string") != 0 && stricmp(pstProperty, "tooltipstring") != 0 && stricmp(pstProperty, "ticks_format") != 0) /* Added for uicontrols */ { if (isScalar(pvApiCtx, piAddr3) == 0) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, iPos + 1); return 1; } if (getAllocatedSingleString(pvApiCtx, piAddr3, (char**)&pvData)) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1); return 1; } iRows3 = (int)strlen((char*)pvData); iCols3 = 1; isMatrixOfString = 0; } else { isMatrixOfString = 1; getAllocatedMatrixOfString(pvApiCtx, piAddr3, &iRows3, &iCols3, (char***)&pvData); } break; case sci_list : iCols3 = 1; sciErr = getListItemNumber(pvApiCtx, piAddr3, &iRows3); pvData = (void*)piAddr3; /* In this case l3 is the list position in stack */ break; default : pvData = (void*)piAddr3; /* In this case l3 is the list position in stack */ break; } if (sciErr.iErr) { freeAllocatedSingleString(pstProperty); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iPos + 1); return 1; } } setStatus = callSetProperty(pvApiCtx, iObjUID, pvData, iType3, iRows3, iCols3, pstProperty); if (iType3 == sci_strings) { //free allacted data if (isMatrixOfString == 1) { freeAllocatedMatrixOfString(iRows3, iCols3, (char**)pvData); } else { freeAllocatedSingleString((char*)pvData); } } freeAllocatedSingleString(pstProperty); } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_figure(char * fname, void* pvApiCtx) { SciErr sciErr; int* piAddr = NULL; int iFig = 0; int iRhs = nbInputArgument(pvApiCtx); int iId = 0; int iPos = 0; int i = 0; int iAxes = 0; int iPropertyOffset = 0; BOOL bDoCreation = TRUE; BOOL bVisible = TRUE; // Create a visible figure by default BOOL bDockable = TRUE; // Create a dockable figure by default BOOL bDefaultAxes = TRUE; // Create an Axes by default double* figureSize = NULL; double* axesSize = NULL; double* position = NULL; double val[4]; BOOL bMenuBar = TRUE; BOOL bToolBar = TRUE; BOOL bInfoBar = TRUE; BOOL bResize = TRUE; int iMenubarType = 1; // Create a 'figure' menubar by default int iToolbarType = 1; // Create a 'figure' toolbar by default double dblId = 0; BOOL status = FALSE; //figure(num) -> scf(num) //figure() -> scf() //figure(x, "...", ...) // figure() if (iRhs == 0) // Auto ID { iId = getValidDefaultFigureId(); iFig = createNewFigureWithAxes(); setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int, 1); iAxes = setDefaultProperties(iFig, TRUE); initBar(iFig, bMenuBar, bToolBar, bInfoBar); createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig)); AssignOutputVariable(pvApiCtx, 1) = iRhs + 1; ReturnArguments(pvApiCtx); return 0; } if (iRhs == 1) { //figure(x); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1); return 0; } if (isVarMatrixType(pvApiCtx, piAddr) == 0) { Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 1); return 0; } if (getScalarDouble(pvApiCtx, piAddr, &dblId)) { Scierror(999, _("%s: No more memory.\n"), fname); return 0; } iId = (int)(dblId + 0.5); //avoid 1.999 -> 1 //get current fig from id iFig = getFigureFromIndex(iId); if (iFig == 0) // Figure does not exists, create a new one { iFig = createNewFigureWithAxes(); setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int, 1); iAxes = setDefaultProperties(iFig, TRUE); } initBar(iFig, bMenuBar, bToolBar, bInfoBar); createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig)); AssignOutputVariable(pvApiCtx, 1) = iRhs + 1; ReturnArguments(pvApiCtx); return 0; } // Prepare property analysis if (iRhs % 2 == 0) { //get highest value of winsid to create the new windows @ + 1 iId = getValidDefaultFigureId(); iPos = 0; } else { iPos = 1; //figure(x, ...); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1); return 0; } if (isVarMatrixType(pvApiCtx, piAddr) == 0) { Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 1); return 0; } if (getScalarDouble(pvApiCtx, piAddr, &dblId)) { Scierror(999, _("%s: No more memory.\n"), fname); return 0; } iId = (int)(dblId + 0.5); //avoid 1.999 -> 1 //get current fig from id iFig = getFigureFromIndex(iId); if (iFig != 0) // Figure already exists { bDoCreation = FALSE; } } if (bDoCreation) { int* piAddrProp = NULL; char* pstProName = NULL; int* piAddrData = NULL; for (i = iPos + 1 ; i <= iRhs ; i += 2) { //get property name sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrProp); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i); return 1; } if (getAllocatedSingleString(pvApiCtx, piAddrProp, &pstProName)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i); return 1; } if (stricmp(pstProName, "dockable") != 0 && stricmp(pstProName, "toolbar") != 0 && stricmp(pstProName, "menubar") != 0 && stricmp(pstProName, "default_axes") != 0 && stricmp(pstProName, "visible") != 0 && stricmp(pstProName, "figure_size") != 0 && stricmp(pstProName, "axes_size") != 0 && stricmp(pstProName, "position") != 0 && stricmp(pstProName, "menubar_visible") != 0 && stricmp(pstProName, "toolbar_visible") != 0 && stricmp(pstProName, "resize") != 0 && stricmp(pstProName, "infobar_visible") != 0) { freeAllocatedSingleString(pstProName); continue; } //get address of value on stack sciErr = getVarAddressFromPosition(pvApiCtx, i + 1, &piAddrData); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } //check property value to compatibility if (stricmp(pstProName, "dockable") == 0) { bDockable = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bDockable == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "dockable", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "toolbar") == 0) { char* pstVal = NULL; if (isStringType(pvApiCtx, piAddrData) == FALSE || isScalar(pvApiCtx, piAddrData) == FALSE) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i); freeAllocatedSingleString(pstProName); } if (getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } if (stricmp(pstVal, "none") == 0) { iToolbarType = 0; } else if (stricmp(pstVal, "figure") == 0) { iToolbarType = 1; } else { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "toolbar", "none", "figure"); freeAllocatedSingleString(pstProName); freeAllocatedSingleString(pstVal); return 1; } freeAllocatedSingleString(pstVal); } else if (stricmp(pstProName, "menubar") == 0) { char* pstVal = NULL; if (isStringType(pvApiCtx, piAddrData) == FALSE || isScalar(pvApiCtx, piAddrData) == FALSE) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } if (getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } if (stricmp(pstVal, "none") == 0) { iMenubarType = 0; } else if (stricmp(pstVal, "figure") == 0) { iMenubarType = 1; } else { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "menubar", "none", "figure"); freeAllocatedSingleString(pstProName); freeAllocatedSingleString(pstVal); return 1; } freeAllocatedSingleString(pstVal); } else if (stricmp(pstProName, "default_axes") == 0) { bDefaultAxes = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bDefaultAxes == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "default_axes", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "visible") == 0) { bVisible = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bVisible == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "visible", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "figure_size") == 0) { int iRows = 0; int iCols = 0; if (isDoubleType(pvApiCtx, piAddrData) == FALSE) { Scierror(999, _("%s: Wrong type for input argument #%d: A double vector expected.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &figureSize); if (iRows * iCols != 2) { Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "figure_size", 2); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "axes_size") == 0) { int iRows = 0; int iCols = 0; if (isDoubleType(pvApiCtx, piAddrData) == FALSE) { Scierror(999, _("%s: Wrong type for input argument #%d: A double vector expected.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &axesSize); if (iRows * iCols != 2) { Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "axes_size", 2); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "position") == 0) { int iRows = 0; int iCols = 0; double* pdbl = NULL; if (isDoubleType(pvApiCtx, piAddrData)) { getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &pdbl); if (iRows * iCols != 4) { Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "position", 4); freeAllocatedSingleString(pstProName); return 1; } position = pdbl; axesSize = (pdbl + 2); } else if (isStringType(pvApiCtx, piAddrData) && isScalar(pvApiCtx, piAddrData)) { char* pstVal = NULL; int iVal = 0; if (getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } iVal = sscanf(pstVal, "%lf|%lf|%lf|%lf", &val[0], &val[1], &val[2], &val[3]); freeAllocatedSingleString(pstVal); if (iVal != 4) { Scierror(999, _("Wrong value for '%s' property: string or 1 x %d real row vector expected.\n"), "position", 4); freeAllocatedSingleString(pstProName); return 1; } position = val; axesSize = (val + 2); } else { Scierror(999, _("Wrong value for '%s' property: string or 1 x %d real row vector expected.\n"), "position", 4); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "resize") == 0) { bResize = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bResize == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "resize", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "menubar_visible") == 0) { bMenuBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bMenuBar == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "menubar_visible", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "toolbar_visible") == 0) { bToolBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bToolBar == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "toolbar_visible", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } else if (stricmp(pstProName, "infobar_visible") == 0) { bInfoBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData); if (bInfoBar == -1) { Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "infobar_visible", "on", "off"); freeAllocatedSingleString(pstProName); return 1; } } freeAllocatedSingleString(pstProName); } iFig = createFigure(bDockable, iMenubarType, iToolbarType, bDefaultAxes, bVisible); setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int, 1); iAxes = setDefaultProperties(iFig, bDefaultAxes); } //set(iFig, iPos, iPos + 1) for (i = iPos + 1 ; i <= iRhs ; i += 2) { int isMatrixOfString = 0; int* piAddrProp = NULL; char* pstProName = NULL; int* piAddrData = NULL; int iRows = 0; int iCols = 0; void* _pvData = NULL; int iType = 0; //get property name sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrProp); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i); return 1; } if (getAllocatedSingleString(pvApiCtx, piAddrProp, &pstProName)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i); return 1; } if (bDoCreation && ( stricmp(pstProName, "dockable") == 0 || stricmp(pstProName, "toolbar") == 0 || stricmp(pstProName, "menubar") == 0 || stricmp(pstProName, "default_axes") == 0 || stricmp(pstProName, "visible") == 0 || stricmp(pstProName, "figure_size") == 0 || stricmp(pstProName, "axes_size") == 0 || stricmp(pstProName, "position") == 0 || stricmp(pstProName, "resize") == 0 || stricmp(pstProName, "menubar_visible") == 0 || stricmp(pstProName, "toolbar_visible") == 0 || stricmp(pstProName, "infobar_visible") == 0)) { // Already set creating new figure // but let the set_ function fail if figure already exists freeAllocatedSingleString(pstProName); continue; } //get address of value on stack sciErr = getVarAddressFromPosition(pvApiCtx, i + 1, &piAddrData); if (sciErr.iErr) { Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i + 1); freeAllocatedSingleString(pstProName); return 1; } getVarType(pvApiCtx, piAddrData, &iType); if ((strcmp(pstProName, "user_data") == 0) || (stricmp(pstProName, "userdata") == 0)) { /* in this case set_user_data_property * directly uses the third position in the stack * to get the variable which is to be set in * the user_data property (any data type is allowed) S. Steer */ _pvData = (void*)piAddrData; /*position in the stack */ iRows = -1; /*unused */ iCols = -1; /*unused */ iType = -1; } else { switch (iType) { case sci_matrix : getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, (double**)&_pvData); break; case sci_boolean : getMatrixOfBoolean(pvApiCtx, piAddrData, &iRows, &iCols, (int**)&_pvData); break; case sci_handles : getMatrixOfHandle(pvApiCtx, piAddrData, &iRows, &iCols, (long long**)&_pvData); break; case sci_strings : if ( strcmp(pstProName, "tics_labels") != 0 && strcmp(pstProName, "auto_ticks") != 0 && strcmp(pstProName, "axes_visible") != 0 && strcmp(pstProName, "axes_reverse") != 0 && strcmp(pstProName, "text") != 0 && stricmp(pstProName, "string") != 0 && stricmp(pstProName, "tooltipstring") != 0) /* Added for uicontrols */ { if (getAllocatedSingleString(pvApiCtx, piAddrData, (char**)&_pvData)) { Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 3); freeAllocatedSingleString(pstProName); return 1; } iRows = (int)strlen((char*)_pvData); iCols = 1; } else { isMatrixOfString = 1; if (getAllocatedMatrixOfString(pvApiCtx, piAddrData, &iRows, &iCols, (char***)&_pvData)) { Scierror(999, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); freeAllocatedSingleString(pstProName); return 1; } } break; case sci_list : iCols = 1; getListItemNumber(pvApiCtx, piAddrData, &iRows); _pvData = (void*)piAddrData; /* In this case l3 is the list position in stack */ break; default : _pvData = (void*)piAddrData; /* In this case l3 is the list position in stack */ break; } } callSetProperty(pvApiCtx, iFig, _pvData, iType, iRows, iCols, pstProName); // If backgroundcolor is set : // * add it to colormap => performed by callSetProperty // * set background to index => performed by callSetProperty // * copy value into axes background property if (stricmp(pstProName, "backgroundcolor") == 0 && iAxes > 0) { int iBackground = 0; int *piBackground = &iBackground; getGraphicObjectProperty(iFig, __GO_BACKGROUND__, jni_int, (void **)&piBackground); setGraphicObjectProperty(iAxes, __GO_BACKGROUND__, piBackground, jni_int, 1); } freeAllocatedSingleString(pstProName); if (iType == sci_strings) { //free allacted data if (isMatrixOfString == 1) { freeAllocatedMatrixOfString(iRows, iCols, (char**)_pvData); } else { freeAllocatedSingleString((char*)_pvData); } } } if (position) { int pos[2]; pos[0] = (int)position[0]; pos[1] = (int)position[1]; setGraphicObjectProperty(iFig, __GO_POSITION__, pos, jni_int_vector, 2); } //axes_size if (axesSize) { int axes[2]; axes[0] = (int)axesSize[0]; axes[1] = (int)axesSize[1]; setGraphicObjectProperty(iFig, __GO_AXES_SIZE__, axes, jni_int_vector, 2); } else //no size, use default axes_size { int* piAxesSize = NULL; getGraphicObjectProperty(getFigureModel(), __GO_AXES_SIZE__, jni_int_vector, (void **)&piAxesSize); setGraphicObjectProperty(iFig, __GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2); releaseGraphicObjectProperty(__GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2); } initBar(iFig, bMenuBar, bToolBar, bInfoBar); if (axesSize == NULL && figureSize) //figure_size { int figure[2]; figure[0] = (int)figureSize[0]; figure[1] = (int)figureSize[1]; setGraphicObjectProperty(iFig, __GO_SIZE__, figure, jni_int_vector, 2); } setGraphicObjectProperty(iFig, __GO_RESIZE__, (void*)&bResize, jni_bool, 1); //return new created fig createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig)); AssignOutputVariable(pvApiCtx, 1) = iRhs + 1; ReturnArguments(pvApiCtx); return 0; }
/*-------------------------------------------------------------------------- * sciset(choice-name,x1,x2,x3,x4,x5) * or xset() *-----------------------------------------------------------*/ int sci_set(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int lw = 0; int isMatrixOfString = 0; char* pstProperty = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { //error return 1; } if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1)) { OverLoad(1); return 0; } CheckRhs(2, 3); CheckLhs(0, 1); if (isDoubleType(pvApiCtx, piAddr1)) /* tclsci handle */ { /* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */ OverLoad(1); return 0; } else /* others types */ { int iRows1 = 0, iCols1 = 0; int iRows2 = 0, iCols2 = 0; int iRows3 = 0, iCols3 = 0; void* _pvData = NULL; unsigned long hdl; char *pobjUID = NULL; int iType1 = 0; int valueType = 0; /* type of the rhs */ int setStatus = 0; /* after the call to sciSet get the status : 0 <=> OK, */ /* -1 <=> Error, */ /* 1 <=> nothing done */ /* set or create a graphic window */ sciErr = getVarType(pvApiCtx, piAddr1, &iType1); if (sciErr.iErr) { //error return 1; } switch (iType1) { case sci_handles: /* first is a scalar argument so it's a gset(hdl,"command",[param]) */ /* F.Leray; INFO: case 9 is considered for a matrix of graphic handles */ CheckRhs(3, 3); if (isScalar(pvApiCtx, piAddr1) == FALSE) { OverLoad(1); return 0; } getScalarHandle(pvApiCtx, piAddr1, (long long*)&hdl); pobjUID = (char*)getObjectFromHandle(hdl); getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); getAllocatedSingleString(pvApiCtx, piAddr2, &pstProperty); valueType = getInputArgumentType(pvApiCtx, 3); getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if ((strcmp(pstProperty, "user_data") == 0) || (stricmp(pstProperty, "userdata") == 0)) { /* in this case set_user_data_property * directly uses the third position in the stack * to get the variable which is to be set in * the user_data property (any data type is allowed) S. Steer */ _pvData = (void*)piAddr3; /*position in the stack */ iRows3 = -1; /*unused */ iCols3 = -1; /*unused */ valueType = -1; } else if (valueType == sci_matrix) { getMatrixOfDouble(pvApiCtx, piAddr3, &iRows3, &iCols3, (double**)&_pvData); } else if (valueType == sci_boolean) { getMatrixOfBoolean(pvApiCtx, piAddr3, &iRows3, &iCols3, (int**)&_pvData); } else if (valueType == sci_handles) { getMatrixOfHandle(pvApiCtx, piAddr3, &iRows3, &iCols3, (long long**)&_pvData); } else if (valueType == sci_strings) { if ( strcmp(pstProperty, "tics_labels") != 0 && strcmp(pstProperty, "auto_ticks") != 0 && strcmp(pstProperty, "axes_visible") != 0 && strcmp(pstProperty, "axes_reverse") != 0 && strcmp(pstProperty, "text") != 0 && stricmp(pstProperty, "string") != 0 && stricmp(pstProperty, "tooltipstring") != 0) /* Added for uicontrols */ { getAllocatedSingleString(pvApiCtx, piAddr3, (char**)&_pvData); iRows3 = (int)strlen((char*)_pvData); iCols3 = 1; } else { isMatrixOfString = 1; getAllocatedMatrixOfString(pvApiCtx, piAddr3, &iRows3, &iCols3, (char***)&_pvData); } } else if (valueType == sci_list) /* Added for callbacks */ { iCols3 = 1; getListItemNumber(pvApiCtx, piAddr3, &iRows3); _pvData = (void*)piAddr3; /* In this case l3 is the list position in stack */ } break; case sci_strings: /* first is a string argument so it's a set("command",[param]) */ CheckRhs(2, 2); getAllocatedSingleString(pvApiCtx, piAddr1, &pstProperty); hdl = 0; pobjUID = NULL; valueType = getInputArgumentType(pvApiCtx, 2); getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (valueType == sci_matrix) { getMatrixOfDouble(pvApiCtx, piAddr2, &iRows3, &iCols3, (double**)&_pvData); } else if (valueType == sci_handles) { getMatrixOfHandle(pvApiCtx, piAddr2, &iRows3, &iCols3, (long long**)&_pvData); } else if (valueType == sci_strings) { if (strcmp(pstProperty, "tics_labels") == 0 || strcmp(pstProperty, "auto_ticks") == 0 || strcmp(pstProperty, "axes_visible") == 0 || strcmp(pstProperty, "axes_reverse") == 0 || strcmp(pstProperty, "text") == 0) { isMatrixOfString = 1; getAllocatedMatrixOfString(pvApiCtx, piAddr2, &iRows3, &iCols3, (char***)&_pvData); } else { getAllocatedSingleString(pvApiCtx, piAddr2, (char**)&_pvData); iRows3 = (int)strlen((char*)_pvData); iCols3 = 1; } } break; default: Scierror(999, _("%s: Wrong type for input argument #%d: String or handle expected.\n"), fname, 1); return 0; break; } if (hdl != 0) { pobjUID = (char*)getObjectFromHandle(hdl); if (pobjUID == NULL) { Scierror(999, _("%s: The handle is not or no more valid.\n"), fname); return 0; } // Only set the property whitout doing anythig else. //static int sciSet(void* _pvCtx, char *pobjUID, char *marker, void* value, int valueType, int *numrow, int *numcol) setStatus = callSetProperty(pvApiCtx, pobjUID, _pvData, valueType, iRows3, iCols3, pstProperty); if (valueType == sci_strings) { //free allacted data if (isMatrixOfString == 1) { freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData); } else { freeAllocatedSingleString((char*)_pvData); } } } else { #define NB_PROPERTIES_SUPPORTED 7 /* No object specified */ /* ONLY supported properties are */ /* 'current_entity' */ /* 'hdl' */ /* 'current_figure' */ /* 'current_axes' */ /* 'default_values' */ /* 'figure_style' for compatibility but do nothing */ /* others values must return a error */ char *propertiesSupported[NB_PROPERTIES_SUPPORTED] = { "current_entity", "hdl", "current_figure", "current_axes", "figure_style", "default_values", "auto_clear" }; int i = 0; int iPropertyFound = 0; for (i = 0; i < NB_PROPERTIES_SUPPORTED; i++) { if (strcmp(propertiesSupported[i], pstProperty) == 0) { iPropertyFound = 1; } } if (iPropertyFound) { // we do nothing with "figure_style" "new" (to remove in 5.4) int bDoSet = ((isMatrixOfString) && (strcmp(pstProperty, "figure_style") == 0) && (strcmp(((char**)_pvData)[0], "new") == 0)) != 1; if (bDoSet) { setStatus = callSetProperty(pvApiCtx, NULL, _pvData, valueType, iRows3, iCols3, pstProperty); if (valueType == sci_strings) { //free allocated data if (isMatrixOfString == 1) { freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData); } else { freeAllocatedSingleString((char*)_pvData); } } } } else { Scierror(999, _("%s: Wrong value for input argument #%d: a valid property expected.\n"), fname, 1); if (isMatrixOfString) { freeArrayOfString((char **)_pvData, iRows3 * iCols3); } return 0; } } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); } return 0; }