Fix memleaks and slightly improve perfs
[scilab.git] / scilab / modules / graphics / src / c / sciCall.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2002-2004 - INRIA - Djalel Abdemouche
4  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
5  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
6  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
13  *
14  */
15
16 /*------------------------------------------------------------------------
17  *    Graphic library
18  *    Graphic subroutines interface
19  --------------------------------------------------------------------------*/
20 #include <math.h>
21 #include <stdio.h>
22 #include <string.h>
23
24 #include "SetProperty.h"
25 #include "GetProperty.h"
26 #include "DrawObjects.h"
27 #include "BuildObjects.h"
28 #include "BasicAlgos.h"
29 #include "math_graphics.h"
30 #include "PloEch.h"
31 #include "Axes.h"
32 #include "Fec.h"
33 #include "GrayPlot.h"
34 #include "localization.h"
35 #include "MALLOC.h" /* MALLOC */
36 #include "Scierror.h"
37 #include "sciCall.h"
38 #include "Plot2d.h"
39 #include "HandleManagement.h"
40 #include "stack-def.h" /* bsiz */
41
42 #include "setGraphicObjectProperty.h"
43 #include "getGraphicObjectProperty.h"
44 #include "createGraphicObject.h"
45 #include "graphicObjectProperties.h"
46 #include "CurrentFigure.h"
47 #include "CurrentSubwin.h"
48 #include "CurrentObject.h"
49
50 /**
51  * Put min and max of vector in dMin and dMax.
52  * If no min and max can't be found (no finite data in dMin or dMax),
53  * then use the default values
54  */
55 static void getDrect(const double vector[], int nbElements,
56                      double * dMin, double * dMax,
57                      double defaultMin, double defaultMax);
58 /*------------------------------------------------
59  * Objrect :
60  * On recupere la figure courante, puis on recupere la sous fenetre qui y est selectionnee
61  *   puis on contruit le rectangle, qu on le place comme objet courant
62  * ensuite il reste qu'appeler la fonction du dessin de l'objet
63  *-----------------------------------------------*/
64
65 void Objrect ( double * x         ,
66                double * y         ,
67                double * width     ,
68                double * height    ,
69                int    * foreground,
70                int    * background,
71                BOOL     isfilled  ,
72                BOOL     isline    ,
73                long   * hdl       )
74 {
75     char* newObjUID = NULL;
76     char* psubwinUID = NULL;
77     char* pFigureUID = NULL;
78
79     pFigureUID = (char*)getCurrentFigure();
80     psubwinUID = (char*)getCurrentSubWin();
81
82     /* check if the auto_clear property is on and then erase everything */
83     checkRedrawing();
84     /*newObjUID = ConstructRectangle(psubwinUID , *x, *y, *height, *width,
85       foreground, background, isfilled, isline);*/
86
87     newObjUID = constructRectangles(psubwinUID, *x, *y, *height, *width,
88                                     foreground == NULL ? -1 : *foreground,
89                                     background == NULL ? -1 : *background,
90                                     (int)isfilled, (int)isline);
91
92     if (newObjUID == NULL)
93     {
94         /* an error occurred */
95         *hdl = -1;
96         return;
97     }
98
99     setCurrentObject(newObjUID);
100     *hdl = getHandle(newObjUID);
101
102     releaseGraphicObjectProperty(-1, newObjUID, jni_string, 0);
103 }
104
105
106 /*----------------------------------------------
107  * Objarc :
108  *-----------------------------------------------*/
109
110 void Objarc( double * angle1    ,
111              double * angle2    ,
112              double * x         ,
113              double * y         ,
114              double * width     ,
115              double * height    ,
116              int    * foreground,
117              int    * background,
118              BOOL     isfilled  ,
119              BOOL     isline    ,
120              long   * hdl        )
121 {
122     char * psubwinUID = NULL;
123     char * pobjUID = NULL;
124
125     psubwinUID = (char*)getCurrentSubWin();
126     checkRedrawing();
127     pobjUID = ConstructArc(psubwinUID, *x, *y,
128                            *height, *width, *angle1, *angle2, foreground, background, isfilled, isline);
129     setCurrentObject(pobjUID);
130
131     *hdl = getHandle(pobjUID);
132     releaseGraphicObjectProperty(__GO_PARENT__, pobjUID, jni_string, 1);
133 }
134
135 /*------------------------------------------------
136  * Objpoly :
137  *-----------------------------------------------*/
138
139 void Objpoly ( double  * x     ,
140                double  * y     ,
141                int   n     ,
142                int   closed,
143                int       mark  ,
144                long    * hdl    )
145 {
146     char * pfigureUID = NULL;
147     char * psubwinUID = NULL;
148     char * pobjUID = NULL;
149
150     psubwinUID = (char*)getCurrentSubWin();
151
152     checkRedrawing();
153
154     if (mark <= 0)
155     {
156         int absmark = abs(mark);
157         pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n, 1,
158                                     NULL, NULL, &absmark, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
159     }
160     else
161     {
162         pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n, 1,
163                                     &mark, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
164     }
165
166     if (pobjUID == NULL)
167     {
168         Scierror(999, _("%s: No more memory.\n"), "Objpoly");
169         return;
170     }
171
172     setCurrentObject(pobjUID);
173     *hdl = getHandle(pobjUID);
174
175     releaseGraphicObjectProperty(__GO_POLYLINE__, pobjUID, jni_string, 1);
176 }
177
178
179 /*------------------------------------------------
180  * Objfpoly :
181  *-----------------------------------------------*/
182
183 void Objfpoly ( double  * x    ,
184                 double  * y    ,
185                 int   n    ,
186                 int * style,
187                 long    * hdl  ,
188                 int   shading )
189 {
190     char* psubwinUID = NULL;
191     char* pobjUID = NULL;
192
193     int fillcolor = 0;
194     int contourcolor = 0;
195     int *piContourColor = &contourcolor;
196
197     int closed = 1; /* we close the polyline by default */
198
199     psubwinUID = (char*)getOrCreateDefaultSubwin();
200
201     checkRedrawing();
202
203     if (shading == 2)
204     {
205         /* interpolated shading is "on" */
206         pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n,
207                                     1, NULL, style, NULL, NULL, NULL, FALSE, TRUE, FALSE, TRUE);
208     }
209     else
210     {
211
212         /* flat mode is "on" */
213         if (*style < 0)
214         {
215             fillcolor = abs(*style);
216             pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n,
217                                         1, NULL, &fillcolor, NULL, NULL, NULL, FALSE, TRUE, FALSE, FALSE);
218         }
219         else if (*style == 0)
220         {
221             getGraphicObjectProperty(psubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piContourColor);
222             pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n,
223                                         1, &contourcolor, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
224         }
225         else
226         {
227             /* *style > 0*/
228             fillcolor = *style;
229             getGraphicObjectProperty(psubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piContourColor);
230             pobjUID = ConstructPolyline(psubwinUID, x, y, PD0, closed, n,
231                                         1, &contourcolor, &fillcolor, NULL, NULL, NULL, TRUE, TRUE, FALSE, FALSE);
232         }
233
234     }
235
236     if (pobjUID == NULL)
237     {
238         Scierror(999, _("%s: No more memory.\n"), "Objfpoly");
239         return;
240     }
241
242     setCurrentObject(pobjUID);
243     *hdl = getHandle(pobjUID);
244
245     releaseGraphicObjectProperty(__GO_PARENT__, pobjUID, jni_string, 1);
246 }
247
248
249 /*-----------------------------------------------------------
250  *   Objsegs :
251  *-----------------------------------------------------------*/
252 void Objsegs ( int * style,
253                int   flag ,
254                int   n1   ,
255                double  * x    ,
256                double  * y    ,
257                double  * z    ,
258                double    arsize )
259 {
260     char *pobjUID = NULL;
261     char *psubwinUID = NULL;
262     int type = 0, colored = 0;
263     double *fx = NULL, *fy = NULL; // No fx or fy
264     int typeofchamp = -1; /* no champ here, only segs ; this info is useless */
265
266     checkRedrawing() ;
267     psubwinUID = (char*)getCurrentSubWin();
268
269     pobjUID = ConstructSegs(psubwinUID, type,
270                             x, y, z, n1, n1, (z == NULL ? 0 : n1), // x, y and z have the same size n1
271                             fx, fy, flag, style, arsize, colored, typeofchamp);
272
273     if (pobjUID == NULL)
274     {
275         Scierror(999, _("%s: No more memory.\n"), "Objsegs");
276         return;
277     }
278
279     setCurrentObject(pobjUID);
280     releaseGraphicObjectProperty(__GO_SEGS__, pobjUID, jni_string, 1);
281 }
282 /*-----------------------------------------------------------
283  * Objstring:
284  *-----------------------------------------------------------*/
285
286 /* box is an OUTPUT re-used inside matdes.c in scixstring */
287 void Objstring( char            ** fname      ,
288                 int                nbRow      ,
289                 int                nbCol      ,
290                 double             x          ,
291                 double             y          ,
292                 double           * angle      ,
293                 double             box[4]     ,
294                 BOOL               autoSize   ,
295                 double             userSize[2],
296                 long             * hdl        ,
297                 int                centerPos  ,
298                 int              * foreground ,
299                 int              * background ,
300                 BOOL               isboxed    ,
301                 BOOL               isline     ,
302                 BOOL               isfilled   ,
303                 sciTextAlignment   alignment   )
304 {
305     char * psubwinUID = NULL;
306     char * pobjUID = NULL;
307     char * pfigureUID = NULL;
308
309     pfigureUID = (char*)getCurrentFigure();
310     psubwinUID = (char*)getCurrentSubWin();
311
312     checkRedrawing();
313
314     pobjUID = ConstructText( psubwinUID   ,
315                              fname     ,
316                              nbRow     ,
317                              nbCol     ,
318                              x         ,
319                              y         ,
320                              autoSize  ,
321                              userSize  ,
322                              centerPos ,
323                              foreground,
324                              background,
325                              isboxed   ,
326                              isline    ,
327                              isfilled  ,
328                              alignment  );
329
330     if (pobjUID == NULL)
331     {
332         Scierror(999, _("%s: No more memory.\n"), "Objstring");
333         return;
334     }
335
336     *hdl = getHandle(pobjUID);
337
338     setGraphicObjectProperty(pobjUID, __GO_FONT_ANGLE__, angle, jni_double, 1);
339 }
340
341
342 /*------------------------------------------------
343  *  plot2d
344  *-----------------------------------------------*/
345
346 void Objplot2d ( int       ptype     ,
347                  char      logflags[],
348                  double    x[]       ,
349                  double    y[]       ,
350                  int * n1        ,
351                  int * n2        ,
352                  int   style[]   ,
353                  char      strflag[] ,
354                  char      legend[]  ,
355                  double    brect[]   ,
356                  int   aaint[]   ,
357                  BOOL      flagNax    )
358 {
359     plot2dn(ptype, logflags, x, y, n1, n2, style, strflag, legend, brect, aaint, flagNax, 4L, bsiz);
360 }
361
362 /*------------------------------------------------
363  *  grayplot
364  *-----------------------------------------------*/
365 void Objgrayplot ( double    x[]      ,
366                    double    y[]      ,
367                    double    z[]      ,
368                    int * n1       ,
369                    int * n2       ,
370                    char      strflag[],
371                    double    brect[]  ,
372                    int   aaint[]  ,
373                    BOOL      flagNax   )
374 {
375     C2F(xgray)(x, y, z, n1, n2, strflag, brect, aaint, flagNax, bsiz );
376 }
377
378 /*------------------------------------------------
379  *  Matplot
380  *-----------------------------------------------*/
381 void Objmatplot (double    z[]      ,
382                  int * n1       ,
383                  int * n2       ,
384                  char      strflag[],
385                  double    brect[]  ,
386                  int    aaint[]  ,
387                  BOOL      flagNax   )
388 {
389     C2F(xgray1)(z, n1, n2, strflag, brect, aaint, flagNax, bsiz);
390 }
391
392 /*------------------------------------------------
393  *  Matplot1
394  *-----------------------------------------------*/
395 void Objmatplot1 ( double    z[],
396                    int * n1 ,
397                    int * n2 ,
398                    double    xrect[] )
399 {
400     C2F(xgray2)(z, n1, n2, xrect);
401 }
402
403 /*------------------------------------------------
404  *  plot3d
405  *-----------------------------------------------*/
406 void Objplot3d ( char    * fname ,
407                  int * isfac ,
408                  int * izcol ,
409                  double    x[]   ,
410                  double    y[]   ,
411                  double    z[]   ,
412                  double  * zcol  ,
413                  int * m     ,
414                  int * n     ,
415                  double  * theta ,
416                  double  * alpha ,
417                  char    * legend,
418                  int * iflag ,
419                  double  * ebox  ,
420                  int * m1    , /*Adding F.Leray 12.03.04 and 19.03.04*/
421                  int * n1    ,
422                  int * m2    ,
423                  int * n2    ,
424                  int * m3    ,
425                  int * n3    ,
426                  int * m3n   ,
427                  int * n3n    )
428 /* F.Leray 25.04.05 : warning here legends means "X@Y@Z": it is labels writings!! */
429 /* legends has not the same meaning than inside plot2dn (there, it is really the legends of the plotted curves)*/
430 {
431     sciTypeOf3D typeof3d;
432     int flagcolor = 0;
433     long *hdltab = NULL;
434     int i = 0;
435
436     char *psubwinUID = NULL;
437     char *pobjUID = NULL;
438     char *parentFigureUID = NULL;
439
440     double drect[6];
441     double rotationAngles[2];
442     double* dataBounds = NULL;
443     char * loc = NULL;
444     char * legx = NULL;
445     char * legy = NULL;
446     char * legz = NULL;
447     char* labelId = NULL;
448     /*   char * buff = NULL; */
449     int flag_x = 1;
450     int flag_y = 1;
451     int dimvectx = -1;
452     int dimvecty = -1;
453     int view = 0;
454     int linLogFlag;
455     int firstPlot = 0;
456     int *piFirstPlot = &firstPlot;
457
458     int box = 0;
459     int axisVisible = 0;
460     int autoScale = 0;
461     int *piAutoScale = &autoScale;
462
463     int isoview = 0;
464     int clipState = 0;
465
466     char *pNewSurfaceUID = NULL;
467
468
469     /* Initialisation drect A.C pour debuggueur */
470     drect[0] = 0.0;
471     drect[1] = 0.0;
472     drect[2] = 0.0;
473     drect[3] = 0.0;
474     drect[4] = 0.0;
475     drect[5] = 0.0;
476
477     /* =================================================
478      * Force SubWindow properties according to arguments
479      * ================================================= */
480
481     parentFigureUID = (char*)getCurrentFigure();
482     psubwinUID = (char*)getCurrentSubWin();
483
484     checkRedrawing();
485
486     /* Force 3D view */
487     view = 1;
488     setGraphicObjectProperty(psubwinUID, __GO_VIEW__, &view, jni_int, 1);
489
490     if ( legend != NULL )
491     {
492         int textDimensions[2] = {1, 1};
493         /* F.Leray 25.04.05 replace the default labels by the user labels if specified */
494         loc = (char *) MALLOC( (strlen(legend) + 1) * sizeof(char));
495         if ( loc == NULL)
496         {
497             Scierror(999, _("%s: No more memory.\n"), "Objplot3d");
498         }
499
500         strcpy(loc, legend);
501
502         /*   legx=strtok_r(loc,"@",&buff); */
503         legx = strtok(loc, "@");
504
505         if (legx != NULL)
506         {
507             getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LABEL__, jni_string, (void **)&labelId);
508
509             setGraphicObjectProperty(labelId, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
510             setGraphicObjectProperty(labelId, __GO_TEXT_STRINGS__, &legx, jni_string_vector, textDimensions[0]*textDimensions[1]);
511         }
512
513         /*   legy=strtok_r((char *)0,"@",&buff); */
514         legy = strtok((char *)NULL, "@"); /* NULL to begin at the last read character */
515         if ( legy != NULL )
516         {
517             getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LABEL__, jni_string, (void **)&labelId);
518
519             setGraphicObjectProperty(labelId, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
520             setGraphicObjectProperty(labelId, __GO_TEXT_STRINGS__, &legy, jni_string_vector, textDimensions[0]*textDimensions[1]);
521         }
522
523         /*   legz=strtok_r((char *)0,"@",&buff); */
524         legz = strtok((char *)NULL, "@");
525         if ( legz != NULL )
526         {
527             getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LABEL__, jni_string, (void **)&labelId);
528
529             setGraphicObjectProperty(labelId, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
530             setGraphicObjectProperty(labelId, __GO_TEXT_STRINGS__, &legz, jni_string_vector, textDimensions[0]*textDimensions[1]);
531         }
532     }
533
534     /* Force psubwin->logflags to linear */
535     linLogFlag = 0;
536
537     setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOG_FLAG__, &linLogFlag, jni_bool, 1);
538     setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOG_FLAG__, &linLogFlag, jni_bool, 1);
539     setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LOG_FLAG__, &linLogFlag, jni_bool, 1);
540
541
542     getGraphicObjectProperty(psubwinUID, __GO_FIRST_PLOT__, jni_bool, (void **)&piFirstPlot);
543
544     if (firstPlot == 0 && (iflag[2] == 0 || iflag[2] == 1))
545     {
546         /* Nothing to do: we leave as before */
547     }
548     else
549     {
550         int labelVisible;
551
552         if (iflag[2] == 0 || iflag[2] == 1)
553         {
554             if (firstPlot)
555             {
556                 /* 0: OFF */
557                 box = 0;
558
559                 axisVisible = 0;
560                 setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
561                 setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
562                 setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
563
564                 setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &box, jni_int, 1);
565
566                 labelVisible = 0;
567                 getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LABEL__, jni_string, (void **)&labelId);
568                 setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
569                 getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LABEL__, jni_string, (void **)&labelId);
570                 setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
571                 getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LABEL__, jni_string, (void **)&labelId);
572                 setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
573             }
574             /*else no changes : the axes visible properties are driven by the previous plot */
575         }
576         else if (iflag[2] == 2)
577         {
578             /* 2: HIDDEN_AXES */
579             box = 2;
580
581             /* for 2d use only (when switching to 2d mode) */
582             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &box, jni_int, 1);
583
584             axisVisible = 0;
585             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
586             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
587             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
588
589             labelVisible = 0;
590             getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LABEL__, jni_string, (void **)&labelId);
591             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
592             getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LABEL__, jni_string, (void **)&labelId);
593             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
594             getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LABEL__, jni_string, (void **)&labelId);
595             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
596         }
597         else if (iflag[2] == 3)
598         {
599             /* 1: ON */
600             box = 1;
601
602             /* for 2d use only (when switching to 2d mode) */
603             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &box, jni_int, 1);
604
605             axisVisible = 0;
606             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
607             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
608             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
609
610             labelVisible = 1;
611             getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LABEL__, jni_string, (void **)&labelId);
612             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
613             getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LABEL__, jni_string, (void **)&labelId);
614             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
615             getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LABEL__, jni_string, (void **)&labelId);
616             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
617         }
618         else if (iflag[2] == 4)
619         {
620             /* 1: ON */
621             box = 1;
622             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &box, jni_int, 1);
623
624             axisVisible = 1;
625             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
626             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
627             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
628
629             labelVisible = 1;
630             getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LABEL__, jni_string, (void **)&labelId);
631             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
632             getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LABEL__, jni_string, (void **)&labelId);
633             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
634             getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LABEL__, jni_string, (void **)&labelId);
635             setGraphicObjectProperty(labelId, __GO_VISIBLE__, &labelVisible, jni_bool, 1);
636         }
637     }
638
639     rotationAngles[0] = *alpha;
640     rotationAngles[1] = *theta;
641
642     setGraphicObjectProperty(psubwinUID, __GO_ROTATION_ANGLES__, rotationAngles, jni_double_vector, 2);
643
644     getGraphicObjectProperty(psubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
645
646     getGraphicObjectProperty(psubwinUID, __GO_AUTO_SCALE__, jni_bool, (void **)&piAutoScale);
647
648     if (autoScale)
649     {
650         /* compute and merge new specified bounds with data bounds */
651         switch (iflag[1])
652         {
653         case 0:  /* do not change data bounds */
654             break;
655         case 1 :
656         case 3 :
657         case 5 :
658         case 7 : /* Force data bounds=ebox */
659             drect[0] = ebox[0]; /*xmin*/
660             drect[2] = ebox[2]; /*ymin*/
661             drect[1] = ebox[1]; /*xmax*/
662             drect[3] = ebox[3]; /*ymax*/
663             drect[4] = ebox[4]; /*zmin*/
664             drect[5] = ebox[5]; /*zmax*/
665             break;
666         case 2 :
667         case 4 :
668         case 6 :
669         case 8:/* Force data bounds to the x and y bounds */
670             getDrect(x, (*m1) * (*n1), &drect[0], &drect[1], dataBounds[0], dataBounds[1]);
671             getDrect(y, (*m2) * (*n2), &drect[2], &drect[3], dataBounds[2], dataBounds[3]);
672             getDrect(z, (*m3) * (*n3), &drect[4], &drect[5], dataBounds[4], dataBounds[5]);
673             break;
674         }
675
676         /* merge data bounds and drect */
677         if (!firstPlot)
678         {
679             drect[0] = Min(dataBounds[0], drect[0]); /* xmin */
680             drect[1] = Max(dataBounds[1], drect[1]); /* xmax */
681             drect[2] = Min(dataBounds[2], drect[2]); /* ymin */
682             drect[3] = Max(dataBounds[3], drect[3]); /* ymax */
683             drect[4] = Min(dataBounds[4], drect[4]); /* zmin */
684             drect[5] = Max(dataBounds[5], drect[5]); /* zmax */
685         }
686
687         if (iflag[1] != 0)
688         {
689             setGraphicObjectProperty(psubwinUID, __GO_DATA_BOUNDS__, drect, jni_double_vector, 6);
690         }
691     }
692
693     if (iflag[1] != 0)
694     {
695         isoview = ( iflag[1] == 3 || iflag[1] == 4 || iflag[1] == 5 || iflag[1] == 6);
696
697         setGraphicObjectProperty(psubwinUID, __GO_ISOVIEW__, &isoview, jni_bool, 1);
698     }
699
700     /* =================================================
701      * Analyze arguments to find entity type
702      * ================================================= */
703
704     if (*isfac == 1)
705     {
706         if (*izcol == 0)
707         {
708             if (strcmp(fname, "plot3d1") == 0)
709             {
710                 typeof3d = SCI_FAC3D;
711                 flagcolor = 1;
712             }
713             else
714             {
715                 typeof3d = SCI_FAC3D;
716                 flagcolor = 0;
717             }
718         }
719         else if (*izcol == 2)
720         {
721             typeof3d = SCI_FAC3D;
722             flagcolor = 3;
723         }
724         else
725         {
726             typeof3d = SCI_FAC3D;
727             flagcolor = 2;
728         }
729     }
730     else if (*isfac == 0)
731     {
732         if (strcmp(fname, "plot3d1") == 0)
733         {
734             typeof3d = SCI_PLOT3D;
735             flagcolor = 1;
736         }
737         else
738         {
739             typeof3d = SCI_PLOT3D;
740             flagcolor = 0;
741         }
742     }
743     else
744     {
745         typeof3d = SCI_PARAM3D1;
746         flagcolor = 1;
747     }
748
749     /* =================================================
750      * Construct the Entities
751      * ================================================= */
752
753     /*Distinction here between SCI_PARAM3D1 and others*/
754     if ( typeof3d != SCI_PARAM3D1 )
755     {
756         if ( *isfac == 1 )
757         {
758             /* x is considered as a matrix */
759             dimvectx = -1;
760         }
761         else if ( *m1 == 1 ) /* x is a row vector */
762         {
763             dimvectx = *n1;
764         }
765         else if ( *n1 == 1 ) /* x is a column vector */
766         {
767             dimvectx = *m1;
768         }
769         else /* x is a matrix */
770         {
771             dimvectx = -1;
772         }
773
774         if ( dimvectx > 1 )
775         {
776             int monotony = checkMonotony( x, dimvectx );
777             if ( monotony == 0 )
778             {
779                 Scierror(999, _("%s: x vector is not monotonous.\n"), "Objplot3d");
780                 return;
781             }
782
783             flag_x = monotony;
784         }
785
786         if ( *isfac == 1 )
787         {
788             /* y is considered as a matrix */
789             dimvecty = -1;
790         }
791         else if ( *m2 == 1 ) /* y is a row vector */
792         {
793             dimvecty = *n2;
794         }
795         else if ( *n2 == 1 ) /* y is a column vector */
796         {
797             dimvecty = *m2;
798         }
799         else /* y is a matrix */
800         {
801             dimvecty = -1;
802         }
803
804         if ( dimvecty > 1 )
805         {
806             /* test the monotony on y*/
807             int monotony = checkMonotony( y, dimvecty );
808             if ( monotony == 0 )
809             {
810                 Scierror(999, _("%s: y vector is not monotonous.\n"), "Objplot3d");
811                 return;
812             }
813
814             flag_y = monotony;
815         }
816
817         pNewSurfaceUID = ConstructSurface( psubwinUID, typeof3d,
818                                            x, y, z, zcol, *izcol, *m, *n, iflag, ebox, flagcolor,
819                                            isfac, m1, n1, m2, n2, m3, n3, m3n, n3n);
820
821         if ( pNewSurfaceUID == NULL )
822         {
823             Scierror(999, _("%s: No more memory.\n"), "Objplot3d");
824             return;
825         }
826
827         setCurrentObject( pNewSurfaceUID );
828
829         /* Force clipping, 1: CLIPGRF */
830         clipState = 1;
831         setGraphicObjectProperty(pNewSurfaceUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
832
833         releaseGraphicObjectProperty(__GO_PARENT__, pNewSurfaceUID, jni_string, 1);
834     }
835     else
836     {
837         char* pNewPolylineUID = NULL;
838         char* currentSubwinUID = NULL;
839
840         if ((hdltab = MALLOC (*n * sizeof (long))) == NULL)
841         {
842             Scierror(999, "%s: No more memory.\n", fname);
843             return;
844         }
845
846         currentSubwinUID = (char*)getCurrentSubWin();
847
848         for (i = 0; i < *n; ++i)
849         {
850             /* F.Leray Pb here: In fact we do not create a Surface but one or several 3D Polylines
851                Pb comes when wanting to access the fields "surface_color" or "flag" for example
852                in function sciSet (cf. matdes.c).
853                Question 1: Are these properties accessible from a SCI_PARAM3D1 ?
854                Question 2: Is "flag" obsolete and replaced by "color_mode"?*/
855
856             if ((*n > 0) && (zcol != (double *)NULL))
857             {
858                 if ((int) zcol[i] > 0)
859                 {
860                     int intzcol = (int) zcol[i];
861                     pNewPolylineUID = ConstructPolyline
862                         (currentSubwinUID,
863                          &(x[*m * i]), &(y[*m * i]), &(z[*m * i]), 0, *m, 1,
864                          &intzcol, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
865                 }
866                 else
867                 {
868                     int intzcol = (int) - zcol[i];
869                     pNewPolylineUID = ConstructPolyline
870                         (currentSubwinUID,
871                          &(x[*m * i]), &(y[*m * i]), &(z[*m * i]), 0, *m, 1,
872                          NULL, NULL, &intzcol, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
873                 }
874             }
875             else
876             {
877                 /* default case, nothing is given */
878                 int curcolor = 0;
879                 int *piCurColor = &curcolor;
880
881                 getGraphicObjectProperty(currentSubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piCurColor);
882
883                 pNewPolylineUID = ConstructPolyline(currentSubwinUID,
884                                                     &(x[*m * i]), &(y[*m * i]), &(z[*m * i]), 0, *m, 1,
885                                                     &curcolor, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
886             }
887
888             if (pNewPolylineUID == NULL)
889             {
890                 Scierror(999, _("%s: No more memory.\n"), fname);
891                 FREE(hdltab);
892                 return;
893             }
894
895             setCurrentObject(pNewPolylineUID);
896             setGraphicObjectRelationship(currentSubwinUID, pNewPolylineUID);
897             releaseGraphicObjectProperty(__GO_PARENT__, pNewPolylineUID, jni_string, 1);
898             pNewPolylineUID = NULL;
899
900             pobjUID = (char*)getCurrentObject();
901
902             /* Force clipping, 1: CLIPGRF */
903             clipState = 1;
904             setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
905
906             hdltab[i] = getHandle(pobjUID);
907         }
908
909         /** construct Compound and make it current object**/
910         if ( *n > 1 )
911         {
912             char* o = ConstructCompound (hdltab, *n);
913             setCurrentObject(o);
914             releaseGraphicObjectProperty(__GO_PARENT__, o, jni_string, 1);
915         }
916         FREE(hdltab);
917     }
918
919     /* =================================================
920      * Redraw Figure
921      * ================================================= */
922
923     // subwin has been modified
924
925     firstPlot = 0;
926     setGraphicObjectProperty(psubwinUID, __GO_FIRST_PLOT__, &firstPlot, jni_bool, 1);
927
928     FREE(loc);
929     loc = NULL;
930
931 }
932 /*-----------------------------------------------------------
933  * Objaxis:
934  *-----------------------------------------------------------*/
935
936 void Objdrawaxis ( char     dir    ,
937                    char     tics   ,
938                    double * x      ,
939                    int    * nx     ,
940                    double * y      ,
941                    int    * ny     ,
942                    char   * val[]  ,
943                    int      subint ,
944                    char   * format ,
945                    int      font   ,
946                    int      textcol,
947                    int      ticscol,
948                    char     flag   ,
949                    int      seg    ,
950                    int      nb_tics_labels )
951 {
952     char* pobjUID = NULL;
953     char* psubwinUID = NULL;
954
955     psubwinUID = (char*)getCurrentSubWin();
956
957     checkRedrawing();
958
959     pobjUID = ConstructAxis(
960         psubwinUID,
961         dir, tics, x, *nx, y, *ny, val, subint, format, font, textcol, ticscol, flag, seg, nb_tics_labels);
962
963     if (pobjUID == NULL)
964     {
965         Scierror(999, _("%s: No more memory.\n"), "Objdrawaxis");
966         return;
967     }
968
969     setCurrentObject(pobjUID);
970     releaseGraphicObjectProperty(__GO_PARENT__, pobjUID, jni_string, 1);
971 }
972
973 /*-----------------------------------------------------------
974  * Objnumb:
975  *-----------------------------------------------------------*/
976
977 void Objnumb( char          * fname    ,
978               unsigned long   fname_len,
979               int         n        ,
980               int         flag     ,
981               double          x        ,
982               double          y        ,
983               double        * angle    ,
984               double        * box       )
985 {
986     /*** faire une macro scilab sur xstring ****/
987
988
989 }
990
991 /*------------------------------------------------
992  * fec
993  *-----------------------------------------------*/
994 void Objfec ( double    x[]        ,
995               double    y[]        ,
996               double    noeud[]    ,
997               double  * fun        ,
998               int * n          ,
999               int * m          ,
1000               char      strflag[]  ,
1001               char      legend[]   ,
1002               double    brect[]    ,
1003               int   aaint[]    ,
1004               double    Zminmax[]  ,
1005               int   Colminmax[],
1006               int   ColOut[]   ,
1007               BOOL      WithMesh   ,
1008               BOOL      flagNax     )
1009 {
1010     C2F(fec)(x, y, noeud, fun, n, m, strflag, legend, brect, aaint,
1011              Zminmax, Colminmax, ColOut, WithMesh, flagNax, 4L, bsiz);
1012 }
1013 /*------------------------------------------------------------------------*/
1014 static void getDrect(const double vector[], int nbElements,
1015                      double * dMin, double * dMax,
1016                      double defaultMin, double defaultMax)
1017 {
1018     if (containsOneFiniteElement(vector, nbElements))
1019     {
1020         *dMin = Mini(vector, nbElements);
1021         *dMax = Maxi(vector, nbElements);
1022     }
1023     else
1024     {
1025         *dMin = defaultMin;
1026         *dMax = defaultMax;
1027     }
1028 }
1029 /*------------------------------------------------------------------------*/