static char *getPlot3d(char *pAxeUID, scicos_block * block)
{
char *pPlot3d;
sco_data *sco = (sco_data *) * (block->work);
// assert the sco is not NULL
if (sco == NULL)
{
return NULL;
}
// fast path for an existing object
if (sco->scope.cachedPlot3dUID != NULL)
{
return sco->scope.cachedPlot3dUID;
}
pPlot3d = findChildWithKindAt(pAxeUID, __GO_PLOT3D__, 0);
/*
* Allocate if necessary
*/
if (pPlot3d == NULL)
{
pPlot3d = createGraphicObject(__GO_PLOT3D__);
if (pPlot3d != NULL)
{
createDataObject(pPlot3d, __GO_PLOT3D__);
setGraphicObjectRelationship(pAxeUID, pPlot3d);
}
}
/*
* Setup on first access
*/
if (pPlot3d != NULL)
{
setBounds(block, pAxeUID, pPlot3d);
setPlot3dSettings(pPlot3d);
setDefaultValues(block, pPlot3d);
{
int iClipState = 1; //on
setGraphicObjectProperty(pPlot3d, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
}
}
/*
* then cache with a local storage
*/
if (pPlot3d != NULL && sco->scope.cachedPlot3dUID == NULL)
{
sco->scope.cachedPlot3dUID = strdup(pPlot3d);
releaseGraphicObjectProperty(__GO_PARENT__, pPlot3d, jni_string, 1);
}
return sco->scope.cachedPlot3dUID;
}
static int getGrayplot(int iAxeUID, scicos_block * block)
{
int iGrayplot;
int i__0 = 0;
sco_data *sco = (sco_data *) * (block->work);
// assert the sco is not NULL
if (sco == NULL)
{
return 0;
}
// fast path for an existing object
if (sco->scope.cachedGrayplotUID)
{
return sco->scope.cachedGrayplotUID;
}
iGrayplot = findChildWithKindAt(iAxeUID, __GO_GRAYPLOT__, 0);
/*
* Allocate if necessary
*/
if (iGrayplot == 0)
{
iGrayplot = createGraphicObject(__GO_GRAYPLOT__);
if (iGrayplot != 0)
{
createDataObject(iGrayplot, __GO_GRAYPLOT__);
setGraphicObjectRelationship(iAxeUID, iGrayplot);
}
else
{
return 0;
}
}
/*
* Setup on first access
*/
setGraphicObjectProperty(iGrayplot, __GO_DATA_MAPPING__, &i__0, jni_int, 1);
setBounds(block, iAxeUID, iGrayplot);
setDefaultValues(block, iGrayplot);
{
int iClipState = 1; //on
setGraphicObjectProperty(iGrayplot, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
}
/*
* then cache with a local storage
*/
sco->scope.cachedGrayplotUID = iGrayplot;
return sco->scope.cachedGrayplotUID;
}
static int getPlot3d(int iAxeUID, scicos_block * block)
{
int iPlot3d;
sco_data *sco = (sco_data *) * (block->work);
// assert the sco is not NULL
if (sco == NULL)
{
return 0;
}
// fast path for an existing object
if (sco->scope.cachedPlot3dUID)
{
return sco->scope.cachedPlot3dUID;
}
iPlot3d = findChildWithKindAt(iAxeUID, __GO_PLOT3D__, 0);
/*
* Allocate if necessary
*/
if (iPlot3d == 0)
{
iPlot3d = createGraphicObject(__GO_PLOT3D__);
if (iPlot3d != 0)
{
createDataObject(iPlot3d, __GO_PLOT3D__);
setGraphicObjectRelationship(iAxeUID, iPlot3d);
}
else
{
return 0;
}
}
/*
* Setup on first access
*/
setBounds(block, iAxeUID, iPlot3d);
setPlot3dSettings(iPlot3d);
setDefaultValues(block, iPlot3d);
{
int iClipState = 1; //on
setGraphicObjectProperty(iPlot3d, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
}
/*
* then cache with a local storage
*/
sco->scope.cachedPlot3dUID = iPlot3d;
return sco->scope.cachedPlot3dUID;
}
/* allocate and set a new label to default values */
int initLabel(int iParentObjUID)
{
int iNewLabel = NULL;
int iHidden = 1;
int autoPosition = 1;
iNewLabel = createGraphicObject(__GO_LABEL__);
/* Hide Label as they are non explicit children */
setGraphicObjectProperty(iNewLabel, __GO_HIDDEN__, &iHidden, jni_bool, 1);
setGraphicObjectProperty(iNewLabel, __GO_AUTO_POSITION__, &autoPosition, jni_bool, 1);
setGraphicObjectProperty(iNewLabel, __GO_AUTO_ROTATION__, &autoPosition, jni_bool, 1);
/* Sets the label's parent */
setGraphicObjectRelationship(iParentObjUID, iNewLabel);
cloneGraphicContext(iParentObjUID, iNewLabel);
cloneFontContext(iParentObjUID, iNewLabel);
return iNewLabel;
}
static int getSegs(int iAxeUID, scicos_block * block, int input)
{
int iSegs;
BOOL b__true = TRUE;
double d__1 = 1.0;
double d__0 = 0.0;
int color;
sco_data *sco = getScoData(block);
// assert the sco is not NULL
if (sco == NULL || sco->scope.cachedSegsUIDs == NULL)
{
return 0;
}
// fast path for an existing object
if (sco->scope.cachedSegsUIDs[input])
{
return sco->scope.cachedSegsUIDs[input];
}
iSegs = findChildWithKindAt(iAxeUID, __GO_SEGS__, input);
/*
* Allocate if necessary
*/
if (iSegs == 0)
{
iSegs = createGraphicObject(__GO_SEGS__);
if (iSegs != 0)
{
createDataObject(iSegs, __GO_SEGS__);
setGraphicObjectRelationship(iAxeUID, iSegs);
}
else
{
return 0;
}
}
/*
* Setup on first access
*/
setGraphicObjectProperty(iSegs, __GO_NUMBER_ARROWS__, &sco->internal.maxNumberOfPoints[input], jni_int, 1);
// Setup properties
setGraphicObjectProperty(iSegs, __GO_LINE_THICKNESS__, &d__1, jni_double, 1);
setGraphicObjectProperty(iSegs, __GO_ARROW_SIZE__, &d__0, jni_double, 1);
color = block->ipar[2 + input];
if (color > 0)
{
setGraphicObjectProperty(iSegs, __GO_LINE_MODE__, &b__true, jni_bool, 1);
setGraphicObjectProperty(iSegs, __GO_SEGS_COLORS__, &color, jni_int_vector, 1);
}
else
{
int iMarkSize = 4;
color = -color;
setGraphicObjectProperty(iSegs, __GO_MARK_MODE__, &b__true, jni_bool, 1);
setGraphicObjectProperty(iSegs, __GO_MARK_STYLE__, &color, jni_int, 1);
setGraphicObjectProperty(iSegs, __GO_MARK_SIZE__, &iMarkSize, jni_int, 1);
}
{
int iClipState = 1; //on
setGraphicObjectProperty(iSegs, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
}
/*
* then cache with a local storage
*/
sco->scope.cachedSegsUIDs[input] = iSegs;
return sco->scope.cachedSegsUIDs[input];
}
static char *getPolyline(char *pAxeUID, scicos_block * block, int row)
{
char *pPolyline;
static double d__0 = 0.0;
static BOOL b__true = TRUE;
int color;
int markSize;
double lineThickness;
sco_data *sco = (sco_data *) * (block->work);
// assert the sco is not NULL
if (sco == NULL)
{
return NULL;
}
// fast path for an existing object
if (sco->scope.cachedPolylinesUIDs != NULL && sco->scope.cachedPolylinesUIDs[row] != NULL)
{
return sco->scope.cachedPolylinesUIDs[row];
}
pPolyline = findChildWithKindAt(pAxeUID, __GO_POLYLINE__, row);
/*
* Allocate if necessary
*/
if (pPolyline == NULL)
{
pPolyline = createGraphicObject(__GO_POLYLINE__);
if (pPolyline != NULL)
{
createDataObject(pPolyline, __GO_POLYLINE__);
setGraphicObjectRelationship(pAxeUID, pPolyline);
}
}
/*
* Setup on first access
*/
if (pPolyline != NULL)
{
/*
* Default setup of the nGons property
*/
{
int nGons = 1;
setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_NUM_GONS__, &nGons, jni_int, 1);
}
color = block->ipar[3 + row];
markSize = block->ipar[3 + block->ipar[1] + row];
lineThickness = (double)markSize;
if (color > 0)
{
setGraphicObjectProperty(pPolyline, __GO_LINE_MODE__, &b__true, jni_bool, 1);
setGraphicObjectProperty(pPolyline, __GO_LINE_COLOR__, &color, jni_int, 1);
setGraphicObjectProperty(pPolyline, __GO_LINE_THICKNESS__, &lineThickness, jni_double, 1);
}
else
{
color = -color;
setGraphicObjectProperty(pPolyline, __GO_MARK_MODE__, &b__true, jni_bool, 1);
setGraphicObjectProperty(pPolyline, __GO_MARK_STYLE__, &color, jni_int, 1);
setGraphicObjectProperty(pPolyline, __GO_MARK_SIZE__, &markSize, jni_int, 1);
}
{
int iClipState = 1; //on
setGraphicObjectProperty(pPolyline, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
}
}
/*
* then cache with a local storage
*/
if (pPolyline != NULL && sco->scope.cachedPolylinesUIDs != NULL && sco->scope.cachedPolylinesUIDs[row] == NULL)
{
sco->scope.cachedPolylinesUIDs[row] = strdup(pPolyline);
releaseGraphicObjectProperty(__GO_PARENT__, pPolyline, jni_string, 1);
}
return sco->scope.cachedPolylinesUIDs[row];
}
/* DJ.A 08/01/04 */
int C2F(graphicsmodels) (void)
{
double margins[4];
double clipRegion[4];
int clipRegionSet = 0;
int firstPlot = 0;
int result = 0;
int iFiguremdlUID = 0;
int iAxesmdlUID = 0;
/*
** Init Figure Model
*/
// Create default figure by Asking MVC a new one.
iFiguremdlUID = createGraphicObject(__GO_FIGUREMODEL__);
setFigureModel(iFiguremdlUID);
InitFigureModel(iFiguremdlUID);
sciInitGraphicMode(iFiguremdlUID);
/*
** Init Axes Model
*/
// Create default Axes by Asking MVC a new one.
iAxesmdlUID = createGraphicObject(__GO_AXESMODEL__);
setAxesModel(iAxesmdlUID);
/* Sets the parent-child relationship between the default Figure and Axes */
setGraphicObjectRelationship(iFiguremdlUID, iAxesmdlUID);
/* Axes Model properties */
result = InitAxesModel();
if (result < 0)
{
strcpy(error_message, _("Default axes cannot be created.\n"));
return 0;
}
/* Margins and clip region */
margins[0] = 0.125;
margins[1] = 0.125;
margins[2] = 0.125;
margins[3] = 0.125;
setGraphicObjectProperty(iAxesmdlUID, __GO_MARGINS__, margins, jni_double_vector, 4);
clipRegion[0] = 0.0;
clipRegion[1] = 0.0;
clipRegion[2] = 0.0;
clipRegion[3] = 0.0;
setGraphicObjectProperty(iAxesmdlUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
clipRegionSet = 0;
setGraphicObjectProperty(iAxesmdlUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
/*
* Specifies that no high-level drawing function has been called yet.
*/
firstPlot = 1;
setGraphicObjectProperty(iAxesmdlUID, __GO_FIRST_PLOT__, &firstPlot, jni_bool, 1);
#if 0
ppaxesmdl->FirstPlot = TRUE;
#endif
return 1;
}
/*--------------------------------------------------------------------------*/
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_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_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 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;
}
static char *getPolyline(char *pAxeUID, scicos_block * block, int input, int row)
{
char *pPolyline;
double d__0 = 0.0;
BOOL b__true = TRUE;
int color;
sco_data *sco = (sco_data *) * (block->work);
// assert the sco is not NULL
if (sco == NULL)
{
return NULL;
}
// fast path for an existing object
if (sco->scope.cachedPolylinesUIDs != NULL && sco->scope.cachedPolylinesUIDs[input] != NULL && sco->scope.cachedPolylinesUIDs[input][row] != NULL)
{
return sco->scope.cachedPolylinesUIDs[input][row];
}
pPolyline = findChildWithKindAt(pAxeUID, __GO_POLYLINE__, row);
/*
* Allocate if necessary
*/
if (pPolyline == NULL)
{
pPolyline = createGraphicObject(__GO_POLYLINE__);
if (pPolyline != NULL)
{
createDataObject(pPolyline, __GO_POLYLINE__);
setGraphicObjectRelationship(pAxeUID, pPolyline);
}
}
/*
* Setup on first access
*/
if (pPolyline != NULL)
{
/*
* Default setup (will crash if removed)
*/
{
int polylineSize[2] = { 1, block->ipar[2] };
setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, polylineSize, jni_int_vector, 2);
}
setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_X__, &d__0, jni_double_vector, 1);
setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_Y__, &d__0, jni_double_vector, 1);
// ipar=[win;size(in,'*');N;wpos(:);wdim(:);in(:);clrs(:);heritance]
// 1 1 1 2 2 nin nin 1
color = block->ipar[7 + block->nin + input + row];
if (color > 0)
{
LOG("%s: %s at %d at %d to %d\n", "cmscope", "set lines mode", input, row, color);
setGraphicObjectProperty(pPolyline, __GO_LINE_MODE__, &b__true, jni_bool, 1);
setGraphicObjectProperty(pPolyline, __GO_LINE_COLOR__, &color, jni_int, 1);
}
else
{
color = -color;
LOG("%s: %s at %d at %d to %d\n", "cmscope", "set mark mode", input, row, -color);
setGraphicObjectProperty(pPolyline, __GO_MARK_MODE__, &b__true, jni_bool, 1);
setGraphicObjectProperty(pPolyline, __GO_MARK_STYLE__, &color, jni_int, 1);
}
{
int iClipState = 1; //on
setGraphicObjectProperty(pPolyline, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
}
}
/*
* then cache with local storage
*/
if (sco->scope.cachedPolylinesUIDs != NULL && sco->scope.cachedPolylinesUIDs[input] != NULL)
{
sco->scope.cachedPolylinesUIDs[input][row] = strdup(pPolyline);
releaseGraphicObjectProperty(__GO_PARENT__, pPolyline, jni_string, 1);
}
return sco->scope.cachedPolylinesUIDs[input][row];
}
