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