/*------------------------------------------------------------------------*/
int set_current_entity_property(void* _pvCtx, char* pobjUID, size_t stackPointer, int valueType, int nbRow, int nbCol )
{
char* curEntity = NULL ;
if (pobjUID != NULL)
{
/* This property should not be called on an handle */
Scierror(999, _("'%s' property does not exist for this handle.\n"), "current_entity");
return -1;
}
if ( !( valueType == sci_handles ) )
{
Scierror(999, _("Wrong type for '%s' property: Handle expected.\n"), "current_entity");
return SET_PROPERTY_ERROR ;
}
curEntity = (char*)getObjectFromHandle( getHandleFromStack( stackPointer ) ) ;
if ( curEntity == NULL )
{
Scierror(999, _("Wrong value for '%s' property: Must be a valid handle.\n"), "current_entity");
return SET_PROPERTY_ERROR ;
}
setCurrentObject(curEntity) ;
return SET_PROPERTY_SUCCEED ;
}
/*
For matplot1
*/
int C2F(implot1)(unsigned char *z, int *n1, int *n2, double *xrect, int plottype)
{
int iSubwinUID = 0;
int iGrayplotUID = 0;
BOOL isRedrawn = FALSE;
double y = 0; /* void for ConstructGrayplot */
int clipState = 0;
int firstPlot = 0;
isRedrawn = checkRedrawing();
/*---- Boundaries of the frame ----*/
iSubwinUID = getCurrentSubWin();
/* Force "cligrf" clipping (1) */
clipState = 1;
setGraphicObjectProperty(iSubwinUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
iGrayplotUID = ConstructImplot(iSubwinUID, xrect, z, *n1 + 1, *n2 + 1, plottype);
if (iGrayplotUID == 0)
{
// allocation error
Scierror(999, _("%s: No more memory.\n"), "grayplot");
return -1;
}
setCurrentObject(iGrayplotUID);
setGraphicObjectProperty(iSubwinUID, __GO_FIRST_PLOT__, &firstPlot, jni_bool, 1);
return (0);
}
/*--------------------------------------------------------------------------*/
int sci_xfarcs(char *fname, unsigned long fname_len)
{
int m1 = 0, n1 = 0, l1 = 0;
int m2 = 0, n2 = 0, l2 = 0;
long hdl = 0;
int i = 0;
double angle1 = 0.0;
double angle2 = 0.0;
CheckRhs(1, 2);
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
if (m1 != 6)
{
Scierror(999, _("%s: Wrong size for input argument #%d: %s expected.\n"), fname, 1, "(6,n)");
return 0;
}
if (Rhs == 2)
{
GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
CheckVector(2, m2, n2);
if (n1 != m2 * n2)
{
Scierror(999, _("%s: Wrong size for input arguments #%d and #%d.\n"), fname, 1, 2);
return 0;
}
}
else
{
m2 = 1;
n2 = n1;
CreateVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
for (i = 0; i < n2; ++i)
{
*istk(l2 + i) = i + 1;
}
}
getOrCreateDefaultSubwin();
for (i = 0; i < n1; ++i)
{
angle1 = DEG2RAD(*stk(l1 + (6 * i) + 4) / 64.0);
angle2 = DEG2RAD(*stk(l1 + (6 * i) + 5) / 64.0);
Objarc(&angle1, &angle2, stk(l1 + (6 * i)), stk(l1 + (6 * i) + 1),
stk(l1 + (6 * i) + 2), stk(l1 + (6 * i) + 3), istk(l2 + i), istk(l2 + i), TRUE, FALSE, &hdl);
}
/** Construct Compound and make it current object **/
setCurrentObject(ConstructCompoundSeq(n1));
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
void Objarc(double* angle1 ,
double* angle2 ,
double* x ,
double* y ,
double* width ,
double* height ,
int * foreground,
int * background,
BOOL isfilled ,
BOOL isline ,
long * hdl )
{
int iSubwinUID = 0;
int iObjUID = 0;
double rect[6];
iSubwinUID = getCurrentSubWin();
checkRedrawing();
rect[0] = *x;
rect[1] = *x + *width;
rect[2] = *y - *height;
rect[3] = *y;
updateXYDataBounds(iSubwinUID, rect);
iObjUID = createArc(iSubwinUID, *x, *y,
*height, *width, *angle1, *angle2, foreground, background, isfilled, isline);
setCurrentObject(iObjUID);
*hdl = getHandle(iObjUID);
}
/*-----------------------------------------------------------
* Objsegs :
*-----------------------------------------------------------*/
void Objsegs (int * style,
int flag ,
int n1 ,
double * x ,
double * y ,
double * z ,
double arsize)
{
char *pobjUID = NULL;
char *psubwinUID = NULL;
int type = 0, colored = 0;
double *fx = NULL, *fy = NULL; // No fx or fy
int typeofchamp = -1; /* no champ here, only segs ; this info is useless */
checkRedrawing();
psubwinUID = (char*)getCurrentSubWin();
pobjUID = ConstructSegs(psubwinUID, type,
x, y, z, n1, n1, (z == NULL ? 0 : n1), // x, y and z have the same size n1
fx, fy, flag, style, arsize, colored, typeofchamp);
if (pobjUID == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "Objsegs");
return;
}
setCurrentObject(pobjUID);
releaseGraphicObjectProperty(__GO_SEGS__, pobjUID, jni_string, 1);
}
bool GraphEngine::inject(GameObject* object)
{
if (!object->supportsInterface(*this, INTERFACE_GRAPH))
{
return false;
}
// если объект не хочет добавляться
if (!object->beforeInject(*this, INTERFACE_GRAPH))
{
return false;
}
// кешируем объект
if (!makeShadowForObject(object, INTERFACE_GRAPH))
{
return false;
}
// список глобальных объектов
objects.push_back(object);
setCurrentObject(object, INTERFACE_GRAPH);
object->bindEngine(*this, INTERFACE_GRAPH);
return true;
}
NestedVariableEnvironment::NestedVariableEnvironment
(LVariableTable *ext, const Block &blk, CArrRef params /* = Array() */,
CObjRef current_object /* = Object() */)
: m_ext(ext), m_block(blk), m_params(params) {
m_kindOf = KindOfNestedVariableEnvironment;
m_byIdx.resize(m_block.varIndices().size(), NULL);
if (!current_object.isNull()) setCurrentObject(current_object);
}
/**
* Exchanges the tileset data of the tileset wrapped by this document with the
* data in the given \a tileset, and vice-versa.
*/
void TilesetDocument::swapTileset(SharedTileset &tileset)
{
// Bring pointers to safety
setSelectedTiles(QList<Tile*>());
setCurrentObject(mTileset.data());
mTileset->swap(*tileset);
emit tilesetChanged(mTileset.data());
}
void DialogObjects::accept()
{
// get the currently selected object in the list
QModelIndex index = ui->objectListView->selectionModel()->currentIndex();
if (index.isValid()) {
QModelIndex filteredIndex = proxyModel->mapToSource(index);
emit setCurrentObject(objectModel->getSelected(filteredIndex), objectName());
}
close();
}
void ScilabView::deleteObject(char const* pstId)
{
//std::cerr << "[ScilabView] -- deleteObject UID=" << pstId << std::endl;
int iType = -1;
int *piType = &iType;
char *pstParentUID = NULL;
getGraphicObjectProperty(pstId, __GO_TYPE__, jni_int, (void **)&piType);
/*
** If deleting a figure, remove from figure list.
*/
if (iType != -1 && iType == __GO_FIGURE__)
{
m_figureList.erase(pstId);
}
/*
** If deleting current figure find another current one,
** if there is no more figure : NULL
*/
if (m_currentFigure == pstId) // Deleting current figure
{
char* pstrAxesUID = NULL;
if (getNbFigure() != 0)
{
m_currentFigure = m_figureList.rbegin()->first;
getGraphicObjectProperty(m_currentFigure.c_str(), __GO_SELECTED_CHILD__, jni_string, (void**)&pstrAxesUID);
setCurrentSubWin(pstrAxesUID);
}
else
{
setCurrentFigure(NULL);
setCurrentSubWin(NULL);
}
}
/*
** If deleting current entity, set parent as new current.
*/
if (m_currentObject == pstId) // Deleting current object
{
getGraphicObjectProperty(pstId, __GO_PARENT__, jni_string, (void **)&pstParentUID);
setCurrentObject(pstParentUID);
}
// Remove the corresponding handle.
m_uidList.erase(m_handleList.find(pstId)->second);
m_handleList.erase(pstId);
deleteDataObject(pstId);
}
void EPSignalsController::setActiveSignal(EPSignal *signal)
{
if (_activeSignal == signal)
return;
emit currentSignalWillChange(_activeSignal);
_activeSignal = signal;
emit currentSignalDidChange(signal);
emit currentSignalDidChange();
setCurrentObject(signal);
}
void TilesetDocument::removeTiles(const QList<Tile *> &tiles)
{
// Switch current object to the tileset when it is one of the removed tiles
for (Tile *tile : tiles) {
if (tile == currentObject()) {
setCurrentObject(mTileset.data());
break;
}
}
mTileset->removeTiles(tiles);
emit tilesetChanged(mTileset.data());
}
NxDocument::NxDocument(ApplicationCurrent *parent, UiFileItem *_fileItem) :
QObject(parent) {
fileItem = _fileItem;
if(fileItem) {
connect(fileItem, SIGNAL(askFileClose()), SLOT(askFileClose()));
connect(fileItem, SIGNAL(askFileOpen()), SLOT(askFileOpen()));
connect(fileItem, SIGNAL(askFileReload()), SLOT(askFileReload()));
connect(fileItem, SIGNAL(askFileSave()), SLOT(askFileSave()));
}
skipClose = false;
variable = 0;
setCurrentObject(0);
setCurrentGroup(0);
currentCurve = 0;
snapshotsIndex = 0;
isLoaded = false;
}
/*-----------------------------------------------------------
* Objsegs :
*-----------------------------------------------------------*/
void Objsegs (int * style,
int flag ,
int n1 ,
double * x ,
double * y ,
double * z ,
double arsize)
{
int iObjUID = 0;
int iSubwinUID = 0;
int type = 0, colored = 0;
double *fx = NULL, *fy = NULL; // No fx or fy
int typeofchamp = -1; /* no champ here, only segs ; this info is useless */
double rect[6];
checkRedrawing();
iSubwinUID = getCurrentSubWin();
if (n1)
{
MiniMaxi(x, n1, rect, rect + 1);
MiniMaxi(y, n1, rect + 2, rect + 3);
if (z)
{
MiniMaxi(z, n1, rect + 4, rect + 5);
updateXYZDataBounds(iSubwinUID, rect);
}
else
{
updateXYDataBounds(iSubwinUID, rect);
}
}
iObjUID = createSegs(iSubwinUID, x, n1, y, n1, z, (z == NULL ? 0 : n1), style, flag == 0 ? 1 : n1, arsize);
if (iObjUID == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "Objsegs");
return;
}
setCurrentObject(iObjUID);
}
void Objpoly (double * x ,
double * y ,
int n ,
int closed,
int mark ,
long * hdl)
{
int iSubwinUID = 0;
int iObjUID = 0;
double rect[6];
iSubwinUID = getCurrentSubWin();
checkRedrawing();
if (n)
{
MiniMaxi(x, n, rect, rect + 1);
MiniMaxi(y, n, rect + 2, rect + 3);
updateXYDataBounds(iSubwinUID, rect);
}
if (mark <= 0)
{
int absmark = abs(mark);
iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n, 1,
NULL, NULL, &absmark, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
}
else
{
iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n, 1,
&mark, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
}
if (iObjUID == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "Objpoly");
return;
}
setCurrentObject(iObjUID);
*hdl = getHandle(iObjUID);
}
void Objrect (double* x ,
double* y ,
double* width ,
double* height ,
int * foreground,
int * background,
BOOL isfilled ,
BOOL isline ,
long * hdl )
{
int iNewObjUID = 0;
int iSubwinUID = 0;
double rect[6];
iSubwinUID = getCurrentSubWin();
/* check if the auto_clear property is on and then erase everything */
checkRedrawing();
rect[0] = *x;
rect[1] = *x + *width;
rect[2] = *y - *height;
rect[3] = *y;
updateXYDataBounds(iSubwinUID, rect);
/*newObjUID = ConstructRectangle(iSubwinUID , *x, *y, *height, *width,
foreground, background, isfilled, isline);*/
iNewObjUID = createRect(iSubwinUID, *x, *y, *height, *width,
foreground == NULL ? -1 : *foreground,
background == NULL ? -1 : *background,
(int)isfilled, (int)isline);
if (iNewObjUID == 0)
{
/* an error occurred */
*hdl = -1;
return;
}
setCurrentObject(iNewObjUID);
*hdl = getHandle(iNewObjUID);
}
void Objrect (double* x ,
double* y ,
double* width ,
double* height ,
int * foreground,
int * background,
BOOL isfilled ,
BOOL isline ,
long * hdl )
{
char* newObjUID = NULL;
char* psubwinUID = NULL;
char* pFigureUID = NULL;
pFigureUID = (char*)getCurrentFigure();
psubwinUID = (char*)getCurrentSubWin();
/* check if the auto_clear property is on and then erase everything */
checkRedrawing();
/*newObjUID = ConstructRectangle(psubwinUID , *x, *y, *height, *width,
foreground, background, isfilled, isline);*/
newObjUID = constructRectangles(psubwinUID, *x, *y, *height, *width,
foreground == NULL ? -1 : *foreground,
background == NULL ? -1 : *background,
(int)isfilled, (int)isline);
if (newObjUID == NULL)
{
/* an error occurred */
*hdl = -1;
return;
}
setCurrentObject(newObjUID);
*hdl = getHandle(newObjUID);
releaseGraphicObjectProperty(-1, newObjUID, jni_string, 0);
}
void Objpoly (double * x ,
double * y ,
int n ,
int closed,
int mark ,
long * hdl)
{
char * pfigureUID = NULL;
char * psubwinUID = NULL;
char * pobjUID = NULL;
psubwinUID = (char*)getCurrentSubWin();
checkRedrawing();
if (mark <= 0)
{
int absmark = abs(mark);
pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n, 1,
NULL, NULL, &absmark, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
}
else
{
pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n, 1,
&mark, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
}
if (pobjUID == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "Objpoly");
return;
}
setCurrentObject(pobjUID);
*hdl = getHandle(pobjUID);
releaseGraphicObjectProperty(__GO_POLYLINE__, pobjUID, jni_string, 1);
}
void Objdrawaxis (char dir ,
char tics ,
double* x ,
int * nx ,
double* y ,
int * ny ,
char * val[] ,
int subint ,
char * format ,
int font ,
int textcol,
int ticscol,
char flag ,
int seg ,
int nb_tics_labels)
{
char* pobjUID = NULL;
char* psubwinUID = NULL;
psubwinUID = (char*)getCurrentSubWin();
checkRedrawing();
pobjUID = ConstructAxis(
psubwinUID,
dir, tics, x, *nx, y, *ny, val, subint, format, font, textcol, ticscol, flag, seg, nb_tics_labels);
if (pobjUID == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "Objdrawaxis");
return;
}
setCurrentObject(pobjUID);
releaseGraphicObjectProperty(__GO_PARENT__, pobjUID, jni_string, 1);
}
void Objarc(double* angle1 ,
double* angle2 ,
double* x ,
double* y ,
double* width ,
double* height ,
int * foreground,
int * background,
BOOL isfilled ,
BOOL isline ,
long * hdl )
{
char * psubwinUID = NULL;
char * pobjUID = NULL;
psubwinUID = (char*)getCurrentSubWin();
checkRedrawing();
pobjUID = ConstructArc(psubwinUID, *x, *y,
*height, *width, *angle1, *angle2, foreground, background, isfilled, isline);
setCurrentObject(pobjUID);
*hdl = getHandle(pobjUID);
releaseGraphicObjectProperty(__GO_PARENT__, pobjUID, jni_string, 1);
}
/*--------------------------------------------------------------------------*/
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_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_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;
}
/*--------------------------------------------------------------------------*/
int sci_xtitle( char * fname, unsigned long fname_len )
{
int narg;
int nbLabels; /* number of modified labels */
int box = 0;
BOOL isBoxSpecified = FALSE;
char * psubwinUID = NULL;
static rhs_opts opts[] = { {-1,"boxed","i" ,0,0,0},
{-1,NULL ,NULL,0,0,0} };
if (Rhs <= 0)
{
sci_demo(fname, fname_len);
return 0;
}
CheckRhs(1,5);
nbLabels = Rhs;
/* get the given options from the name in opts */
if ( !get_optionals(fname,opts) )
{
/* error */
return 0;
}
/* compatibility with previous version in which box was put */
/* at the fourth position */
if ( Rhs == 4 )
{
int type = GetType(4);
if ( type == 1 || type == 8 )/* double or int */
{
int n,m;
int boxPtr = -1 ; /* pointer of box on the stack */
GetRhsVar(4,MATRIX_OF_INTEGER_DATATYPE,&m,&n,&boxPtr);
CheckScalar(4,m,n);
box = *istk( boxPtr );
nbLabels--; /* it is not a label text */
isBoxSpecified = TRUE;
}
}
if ( opts[0].position != -1 && !isBoxSpecified )
{
/* check if "box" is in the options */
box = *istk(opts[0].l) ;
if ( opts[0].m * opts[0].n != 1 )
{
/* check size */
Scierror( 999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname );
return 1;
}
nbLabels--; /* it is not a label text */
}
psubwinUID = getOrCreateDefaultSubwin();
for ( narg = 1 ; narg <= nbLabels ; narg++)
{
int m,n;
char **Str;
char * modifiedLabel = NULL;
GetRhsVar(narg,MATRIX_OF_STRING_DATATYPE,&m,&n,&Str);
if ( m*n == 0 )
{
continue;
}
switch(narg)
{
case 1:
getGraphicObjectProperty(psubwinUID, __GO_TITLE__, jni_string, &modifiedLabel);
break;
case 2:
getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LABEL__, jni_string, &modifiedLabel);
break;
case 3:
getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LABEL__, jni_string, &modifiedLabel);
break;
case 4:
getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LABEL__, jni_string, &modifiedLabel);
break;
default:
break;
}
#if 0
startFigureDataWriting(pFigure);
#endif
sciSetText(modifiedLabel, Str, m, n);
setGraphicObjectProperty(modifiedLabel, __GO_FILL_MODE__, &box, jni_bool, 1);
#if 0
endFigureDataWriting(pFigure);
#endif
freeArrayOfString(Str,m*n);
}
setCurrentObject(psubwinUID);
#if 0
sciDrawObj(pFigure);
#endif
LhsVar(1)=0;
C2F(putlhsvar)();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_glue( char * fname, unsigned long fname_len )
{
int numrow,numcol,l1,l2,lind,n,cx1=1;
unsigned long hdl = 0, parenthdl = 0 ;
long *handelsvalue = NULL ;
int outindex,i;
char *pstCompoundUID = NULL;
char *pstParentUID = NULL;
char *pstCurrentParentUID = NULL;
char *pobjUID = NULL;
CheckRhs(1,1);
CheckLhs(0,1);
/* set or create a graphic window */
GetRhsVar(1,GRAPHICAL_HANDLE_DATATYPE,&numrow,&numcol,&l1); /* We get the scalar value if it is ones */
n=numrow*numcol;
CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&numrow,&numcol,&l2);
CreateVar(Rhs+2,MATRIX_OF_INTEGER_DATATYPE,&numrow,&numcol,&lind);
if (n>1)
{
C2F(dcopy)(&n, stk(l1), &cx1, stk(l2), &cx1);
C2F(dsort)(stk(l2),&n,istk(lind));
for (i = 1; i < n;i++)
{
long long i1 = (long long)*hstk(l2+i);
long long i2 = (long long)*hstk(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 */
handelsvalue = MALLOC(n*sizeof(long));
for (i = 0 ; i < n ; i++)
{
handelsvalue[i] = (unsigned long) (hstk(l1))[i];
pobjUID = getObjectFromHandle(handelsvalue[i]);
if (pobjUID == NULL)
{
FREE(handelsvalue);
Scierror(999,_("%s: The handle is not or no more valid.\n"),fname);
return 0;
}
getGraphicObjectProperty(pobjUID, __GO_PARENT__, jni_string, &pstCurrentParentUID);
if (i == 0)
{
pstParentUID = pstCurrentParentUID;
}
if (strcmp(pstParentUID, pstCurrentParentUID) != 0)
{
FREE(handelsvalue);
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;
//}
pstCompoundUID = ConstructCompound(handelsvalue, n);
setCurrentObject(pstCompoundUID);
numrow = 1;
numcol = 1;
CreateVar(Rhs+3,GRAPHICAL_HANDLE_DATATYPE,&numrow,&numcol,&outindex);
hstk(outindex)[0] = getHandle(pstCompoundUID);
LhsVar(1) = Rhs+3;
PutLhsVar();
FREE(handelsvalue);
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_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;
}
void TilesetDocument::onWangSetRemoved(WangSet *wangSet)
{
if (wangSet == mCurrentObject)
setCurrentObject(nullptr);
}
/*--------------------------------------------------------------------------*/
int sci_xfarcs(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrl1 = NULL;
double* l1 = NULL;
int* piAddr2 = NULL;
int* l2 = NULL;
int m1 = 0, n1 = 0;
int m2 = 0, n2 = 0;
long hdl = 0;
int iCurrentSubWin = 0;
int i = 0;
double angle1 = 0.0;
double angle2 = 0.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 != 6)
{
Scierror(999, _("%s: Wrong size for input argument #%d: %s expected.\n"), fname, 1, "(6,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 (n1 != m2 * n2)
{
Scierror(999, _("%s: Wrong size 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)
{
*((int*)(l2 + i)) = i + 1;
}
}
iCurrentSubWin = getOrCreateDefaultSubwin();
for (i = 0; i < n1; ++i)
{
angle1 = DEG2RAD(*(l1 + (6 * i) + 4) / 64.0);
angle2 = DEG2RAD(*(l1 + (6 * i) + 5) / 64.0);
Objarc(&angle1, &angle2, (l1 + (6 * i)), (l1 + (6 * i) + 1),
(l1 + (6 * i) + 2), (l1 + (6 * i) + 3), (int*)(l2 + i), (int*)(l2 + i), TRUE, FALSE, &hdl);
}
/** Construct Compound and make it current object **/
{
int o = createCompoundSeq(iCurrentSubWin, n1);
setCurrentObject(o);
}
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
int plot2dn(int ptype, char *logflags, double *x, double *y, int *n1, int *n2, int *style, char *strflag, char *legend, double *brect, int *aaint,
BOOL flagNax, int lstr1, int lstr2)
{
int iSubwinUID = 0;
int iCurFigureUID = 0;
int closeflag = 0;
int jj = 0;
long hdl = 0;
int *pObj = NULL;
int cmpt = 0;
int with_leg = 0;
double drect[6];
char dataflag = 0;
BOOL bounds_changed = FALSE;
BOOL axes_properties_changed = FALSE;
double rotationAngles[2];
int clipState = 0;
int autoScale = 0;
int logFlags[3];
int iTmp = 0;
int *piTmp = &iTmp;
char textLogFlags[3];
int firstPlot = 0;
int newFirstPlot = 0;
int autoSubticks = 0;
iSubwinUID = getOrCreateDefaultSubwin();
/*
* Check if the auto_clear property is on and then erase everything
* To be implemented
*/
checkRedrawing();
rotationAngles[0] = 0.0;
rotationAngles[1] = 270.0;
setGraphicObjectProperty(iSubwinUID, __GO_ROTATION_ANGLES__, rotationAngles, jni_double_vector, 2);
/* Force logflags to those given by argument */
getGraphicObjectProperty(iSubwinUID, __GO_FIRST_PLOT__, jni_bool, (void **)&piTmp);
firstPlot = iTmp;
/* Reset x and y logflags */
if (firstPlot)
{
logFlags[0] = getBooleanLogFlag(logflags[1]);
logFlags[1] = getBooleanLogFlag(logflags[2]);
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_LOG_FLAG__, &logFlags[0], jni_bool, 1);
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_LOG_FLAG__, &logFlags[1], jni_bool, 1);
}
/* Forces "clipgrf" clipping (1) */
clipState = 1;
setGraphicObjectProperty(iSubwinUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
getGraphicObjectProperty(iSubwinUID, __GO_AUTO_SCALE__, jni_bool, (void **)&piTmp);
autoScale = iTmp;
if (autoScale)
{
/* compute and merge new specified bounds with the data bounds */
switch (strflag[1])
{
case '0':
/* do not change data bounds */
break;
case '1':
case '3':
case '5':
case '7':
/* Force data bounds=brect */
re_index_brect(brect, drect);
break;
case '2':
case '4':
case '6':
case '8':
case '9':
/* Force data bounds to the x and y bounds */
if ((int)strlen(logflags) < 1)
{
dataflag = 'g';
}
else
{
dataflag = logflags[0];
}
getGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
logFlags[0] = iTmp;
getGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
logFlags[1] = iTmp;
getGraphicObjectProperty(iSubwinUID, __GO_Z_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
logFlags[2] = iTmp;
/* Conversion required by compute_data_bounds2 */
textLogFlags[0] = getTextLogFlag(logFlags[0]);
textLogFlags[1] = getTextLogFlag(logFlags[1]);
textLogFlags[2] = getTextLogFlag(logFlags[2]);
compute_data_bounds2(0, dataflag, textLogFlags, x, y, *n1, *n2, drect);
break;
}
/* merge data bounds and drect */
if (!firstPlot && (strflag[1] == '5' || strflag[1] == '7' || strflag[1] == '8' || strflag[1] == '9'))
{
double *dataBounds;
getGraphicObjectProperty(iSubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
drect[0] = Min(dataBounds[0], drect[0]); /*xmin */
drect[2] = Min(dataBounds[2], drect[2]); /*ymin */
drect[1] = Max(dataBounds[1], drect[1]); /*xmax */
drect[3] = Max(dataBounds[3], drect[3]); /*ymax */
}
if (strflag[1] != '0')
{
bounds_changed = update_specification_bounds(iSubwinUID, drect, 2);
}
}
if (firstPlot)
{
bounds_changed = TRUE;
}
/* Adapted to the MVC */
axes_properties_changed = strflag2axes_properties(iSubwinUID, strflag);
/* just after strflag2axes_properties */
newFirstPlot = 0;
setGraphicObjectProperty(iSubwinUID, __GO_FIRST_PLOT__, &newFirstPlot, jni_bool, 1);
with_leg = (strflag[0] == '1');
/* F.Leray 07.10.04 : trigger algo to init. manual graduation u_xgrads and
* u_ygrads if nax (in matdes.c which is == aaint HERE) was specified */
/* The MVC AUTO_SUBTICKS property corresponds to !flagNax */
autoSubticks = !flagNax;
setGraphicObjectProperty(iSubwinUID, __GO_AUTO_SUBTICKS__, &autoSubticks, jni_bool, 1);
if (flagNax == TRUE)
{
getGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
logFlags[0] = iTmp;
getGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
logFlags[1] = iTmp;
if (logFlags[0] == 0 && logFlags[1] == 0)
{
int autoTicks = 0;
int i = 0;
int iSize = 0;
double dblFabs = 0;
char** stringVector = NULL;
if (aaint[1] == -1)
{
autoTicks = 1;
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
}
else if (aaint[1] == 0)
{
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_TICKS_LOCATIONS__, NULL, jni_double_vector, 0);
autoTicks = 0;
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
}
else
{
double* dXGrads = (double*) MALLOC(aaint[1] * sizeof(double));
// Compute X grads
dXGrads[0] = drect[0];
if (aaint[1] > 1)
{
double pas = (drect[1] - drect[0]) / (aaint[1] - 1);
for (i = 0; i < aaint[1]; i++)
{
dXGrads[i] = drect[0] + pas * i;
}
}
autoTicks = 0;
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_TICKS_LOCATIONS__, dXGrads, jni_double_vector, aaint[1]);
// Create X Labels
stringVector = (char **) MALLOC(aaint[1] * sizeof(char*));
for (i = 0; i < aaint[1]; i++)
{
iSize = 6;
if (dXGrads[i] < 0)
{
iSize += 2;
}
dblFabs = fabs(dXGrads[i]);
if (dblFabs >= 10)
{
iSize = iSize + (int)floor(log10(dblFabs));
}
stringVector[i] = (char*) MALLOC(iSize * sizeof(char));
sprintf(stringVector[i], "%.3f", dXGrads[i]);
stringVector[i][iSize - 1] = '\0';
}
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, aaint[1]);
for (i = 0; i < aaint[1]; i++)
{
FREE(stringVector[i]);
}
FREE(stringVector);
FREE(dXGrads);
stringVector = NULL;
}
if (aaint[3] == -1)
{
autoTicks = 1;
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
}
else if (aaint[3] == 0)
{
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_TICKS_LOCATIONS__, NULL, jni_double_vector, 0);
autoTicks = 0;
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
}
else
{
double* dYGrads = (double*) MALLOC(aaint[3] * sizeof(double));
// Compute Y grads
dYGrads[0] = drect[2];
if (aaint[3] > 1)
{
double pas = (drect[3] - drect[2]) / (aaint[3] - 1);
for (i = 0; i < aaint[3]; i++)
{
dYGrads[i] = drect[2] + pas * i;
}
}
autoTicks = 0;
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_TICKS_LOCATIONS__, dYGrads, jni_double_vector, aaint[3]);
// Create Y Labels
stringVector = (char**) MALLOC(aaint[3] * sizeof(char*));
for (i = 0; i < aaint[3]; i++)
{
iSize = 6;
if (dYGrads[i] < 0)
{
iSize += 2;
}
dblFabs = fabs(dYGrads[i]);
if (dblFabs >= 10)
{
iSize = iSize + (int)floor(log10(dblFabs));
}
stringVector[i] = (char*) MALLOC(iSize * sizeof(char));
sprintf(stringVector[i], "%.3f", dYGrads[i]);
stringVector[i][iSize - 1] = '\0';
}
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, aaint[3]);
for (i = 0; i < aaint[3]; i++)
{
FREE(stringVector[i]);
}
FREE(stringVector);
FREE(dYGrads);
stringVector = NULL;
}
// X and Y subticks
setGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_SUBTICKS__, aaint, jni_int, 1);
setGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_SUBTICKS__, &aaint[2], jni_int, 1);
}
else
{
sciprint(_("Warning: Nax does not work with logarithmic scaling.\n"));
}
}
/*---- Drawing the curves and the legends ----*/
if (*n1 != 0)
{
if ((pObj = (int*)MALLOC((*n1 + 1) * sizeof(int))) == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "plot2d");
return -1;
}
/*A.Djalel 3D axes */
for (jj = 0; jj < *n1; jj++)
{
int iObjUID = 0;
if (style[jj] > 0)
{
BOOL isline = TRUE;
if (ptype == 3)
{
isline = FALSE;
}
iObjUID = ConstructPolyline(getCurrentSubWin(), &(x[jj * (*n2)]),
&(y[jj * (*n2)]), PD0, closeflag, *n2, ptype,
&style[jj], NULL, NULL, NULL, NULL, isline, FALSE, FALSE, FALSE);
}
else
{
int minusstyle = -style[jj];
iObjUID = ConstructPolyline(getCurrentSubWin(), &(x[jj * (*n2)]),
&(y[jj * (*n2)]), PD0, closeflag, *n2, ptype,
NULL, NULL, &minusstyle, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
}
if (iObjUID == 0)
{
// skip
Scierror(999, _("%s: No more memory.\n"), "plot2d");
}
else
{
setCurrentObject(iObjUID);
pObj[cmpt] = iObjUID;
cmpt++;
}
}
/*---- Drawing the Legends ----*/
if (with_leg)
{
int iLegUID = 0;
char **Str;
int nleg;
if (scitokenize(legend, &Str, &nleg))
{
FREE(pObj);
Scierror(999, _("%s: No more memory.\n"), "plot2d");
return 0;
}
iLegUID = ConstructLegend(getCurrentSubWin(), Str, pObj, Min(nleg, cmpt));
if (iLegUID != 0)
{
int legendLocation;
int contourMode;
/* 9: LOWER_CAPTION */
legendLocation = 9;
setGraphicObjectProperty(iLegUID, __GO_LEGEND_LOCATION__, &legendLocation, jni_int, 1);
contourMode = 0;
setGraphicObjectProperty(iLegUID, __GO_FILL_MODE__, &contourMode, jni_bool, 1);
setGraphicObjectProperty(iLegUID, __GO_LINE_MODE__, &contourMode, jni_bool, 1);
}
freeArrayOfString(Str, nleg);
}
/*---- construct Compound ----*/
if (cmpt > 0)
{
int parentVisible = 0;
int *piParentVisible = &parentVisible;
int iCompoundUID = createCompound(iSubwinUID, pObj, cmpt);
setCurrentObject(iCompoundUID);
}
FREE(pObj);
}
/* End of the curves and legend block */
return 0;
}