Update test now sub ticks property is no more ignored
[scilab.git] / scilab / modules / graphics / src / c / Plo2dn.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) 2010-2011 - DIGITEO - Manuel Juliachs
6  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
7  * Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
8  *
9  * This file must be used under the terms of the CeCILL.
10  * This source file is licensed as described in the file COPYING, which
11  * you should have received as part of this distribution.  The terms
12  * are also available at
13  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
14  *
15  */
16
17 /*------------------------------------------------------------------------
18  *    Graphic library
19  --------------------------------------------------------------------------*/
20 #include <stdio.h>
21 #include <string.h>
22 #include "math_graphics.h"
23 #include "PloEch.h"
24 #include "Plot2d.h"
25
26 #define spINSIDE_SPARSE
27 #include "../../sparse/includes/spConfig.h"
28
29 #include "SetProperty.h"
30 #include "DrawObjects.h"
31 #include "BuildObjects.h"
32 #include "Axes.h"
33 #include "BasicAlgos.h"
34 #include "sciprint.h"
35 #include "Scierror.h"
36
37 #include "MALLOC.h"             /* MALLOC */
38 #include "scitokenize.h"
39 #include "localization.h"
40 #include "get_ticks_utils.h"
41 #include "HandleManagement.h"
42 #include "freeArrayOfString.h"
43
44 #include "getGraphicObjectProperty.h"
45 #include "setGraphicObjectProperty.h"
46 #include "graphicObjectProperties.h"
47 #include "CurrentFigure.h"
48 #include "CurrentSubwin.h"
49 #include "CurrentObject.h"
50
51 /*--------------------------------------------------------------------
52  *  plot2dn(ptype,Logflags,x,y,n1,n2,style,strflag,legend,brect,aaint,lstr1,lstr2)
53  *
54  *  Draw *n1 curves of *n2 points each
55  *
56  *  ptype is an int which gives the polyline drawind mode (0,1,2,3,4)
57  *
58  *  Logflags is a two character string
59  *
60  *  (x[i+(*n2)*j] ,y[i+(*n2)*j]) Double values giving the point
61  *  position of point i of curve j (i=0,*n2-1 j=0,*n1-1)
62  *
63  *  style[*n1]-> give the style to use for each curve
64  *     if style is positive --> a mark is used (mark id = style[i])
65  *     if style is strictly negative --> a dashed line is used
66  *        (dash id = abs(style[i])
67  *     if there's only one curve, style can be of type style[0]=style,
68  *     style[1]=pos ( pos in [1,6])
69  *     pos give the legend position (1 to 6) (this can be iteresting
70  *     if you want to superpose curves with different legends by
71  *     calling plot2d more than one time.
72  *
73  *  strflag[3] is a string
74  *
75  *     if strflag[0] == '1' then legends are added
76  *        legend = "leg1@leg2@....@legn"; gives the legend for each curve
77  *      else no legend
78  *
79  *     if strflag[1] == '1' then  the values of brect are used to fix
80  *        the drawing boundaries :  brect[]= <xmin,ymin,xmax,ymax>;
81  *      if strflag[1] == '2' then the values  are computed from data
82  *      else if strflag[1]=='0' the previous values
83  *                (previous call or defaut values) are used
84  *
85  *     if  strflag[2] == '1' ->then an axis is added
86  *        the number of intervals
87  *        is specified by the vector aaint[4] of integers
88  *         <aaint[0],aaint[1]> specifies the x-axis number of  points
89  *         <aaint[2],aaint[3]> same for y-axis
90  *     if  strflag[2] == '2' -> no axis, only a box around the curves
91  *     else no box and no axis
92
93  * lstr* : unused ( but used by Fortran )
94  *--------------------------------------------------------------------------*/
95
96 int plot2dn(int ptype, char *logflags, double *x, double *y, int *n1, int *n2, int *style, char *strflag, char *legend, double *brect, int *aaint,
97             BOOL flagNax, int lstr1, int lstr2)
98 {
99     char *psubwinUID = NULL;
100     char *curFigureUID = NULL;
101     int closeflag = 0;
102     int jj = 0;
103     long long *tabofhandles = NULL;
104     long hdl = 0;
105     long *hdltab = NULL;
106     int cmpt = 0;
107     int with_leg = 0;
108     double drect[6];
109     char dataflag = 0;
110
111     BOOL bounds_changed = FALSE;
112     BOOL axes_properties_changed = FALSE;
113
114     double rotationAngles[2];
115     int clipState = 0;
116     int autoScale = 0;
117     int logFlags[3];
118     int iTmp = 0;
119     int *piTmp = &iTmp;
120     char textLogFlags[3];
121     int firstPlot = 0;
122     int newFirstPlot = 0;
123     int autoSubticks = 0;
124
125     psubwinUID = (char*)getOrCreateDefaultSubwin();
126
127     /*
128      * Check if the auto_clear property is on and then erase everything
129      * To be implemented
130      */
131     checkRedrawing();
132
133     rotationAngles[0] = 0.0;
134     rotationAngles[1] = 270.0;
135
136     setGraphicObjectProperty(psubwinUID, __GO_ROTATION_ANGLES__, rotationAngles, jni_double_vector, 2);
137
138     /* Force logflags to those given by argument */
139
140     getGraphicObjectProperty(psubwinUID, __GO_FIRST_PLOT__, jni_bool, (void **)&piTmp);
141     firstPlot = iTmp;
142
143     /* Reset x and y logflags */
144     if (firstPlot)
145     {
146         logFlags[0] = getBooleanLogFlag(logflags[1]);
147         logFlags[1] = getBooleanLogFlag(logflags[2]);
148
149         setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOG_FLAG__, &logFlags[0], jni_bool, 1);
150         setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOG_FLAG__, &logFlags[1], jni_bool, 1);
151     }
152
153     /* Forces "clipgrf" clipping (1) */
154     clipState = 1;
155     setGraphicObjectProperty(psubwinUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
156
157     getGraphicObjectProperty(psubwinUID, __GO_AUTO_SCALE__, jni_bool, (void **)&piTmp);
158     autoScale = iTmp;
159
160     if (autoScale)
161     {
162         /* compute and merge new specified bounds with the data bounds */
163         switch (strflag[1])
164         {
165             case '0':
166                 /* do not change data bounds */
167                 break;
168             case '1':
169             case '3':
170             case '5':
171             case '7':
172                 /* Force data bounds=brect */
173                 re_index_brect(brect, drect);
174                 break;
175             case '2':
176             case '4':
177             case '6':
178             case '8':
179             case '9':
180                 /* Force data bounds to the x and y bounds */
181                 if ((int)strlen(logflags) < 1)
182                     dataflag = 'g';
183                 else
184                     dataflag = logflags[0];
185
186                 getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
187                 logFlags[0] = iTmp;
188                 getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
189                 logFlags[1] = iTmp;
190                 getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
191                 logFlags[2] = iTmp;
192
193                 /* Conversion required by compute_data_bounds2 */
194                 textLogFlags[0] = getTextLogFlag(logFlags[0]);
195                 textLogFlags[1] = getTextLogFlag(logFlags[1]);
196                 textLogFlags[2] = getTextLogFlag(logFlags[2]);
197
198                 compute_data_bounds2(0, dataflag, textLogFlags, x, y, *n1, *n2, drect);
199
200                 break;
201         }
202
203         /* merge data bounds and drect */
204         if (!firstPlot && (strflag[1] == '5' || strflag[1] == '7' || strflag[1] == '8' || strflag[1] == '9'))
205         {
206             double *dataBounds;
207
208             getGraphicObjectProperty(psubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
209
210             drect[0] = Min(dataBounds[0], drect[0]);    /*xmin */
211             drect[2] = Min(dataBounds[2], drect[2]);    /*ymin */
212             drect[1] = Max(dataBounds[1], drect[1]);    /*xmax */
213             drect[3] = Max(dataBounds[3], drect[3]);    /*ymax */
214         }
215
216         if (strflag[1] != '0')
217         {
218             bounds_changed = update_specification_bounds(psubwinUID, drect, 2);
219         }
220     }
221
222     if (firstPlot)
223     {
224         bounds_changed = TRUE;
225     }
226
227     /* Adapted to the MVC */
228     axes_properties_changed = strflag2axes_properties(psubwinUID, strflag);
229
230     /* just after strflag2axes_properties */
231     newFirstPlot = 0;
232     setGraphicObjectProperty(psubwinUID, __GO_FIRST_PLOT__, &newFirstPlot, jni_bool, 1);
233
234     with_leg = (strflag[0] == '1');
235
236     /* F.Leray 07.10.04 : trigger algo to init. manual graduation u_xgrads and
237      * u_ygrads if nax (in matdes.c which is == aaint HERE) was specified */
238
239     /* The MVC AUTO_SUBTICKS property corresponds to !flagNax */
240     autoSubticks = !flagNax;
241     setGraphicObjectProperty(psubwinUID, __GO_AUTO_SUBTICKS__, &autoSubticks, jni_bool, 1);
242
243     if (flagNax == TRUE)
244     {
245         getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
246         logFlags[0] = iTmp;
247         getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
248         logFlags[1] = iTmp;
249
250         if (logFlags[0] == 0 && logFlags[1] == 0)
251         {
252             int autoTicks = 0;
253             int i = 0;
254             int iSize = 0;
255             double dblFabs = 0;
256             double* dXGrads = (double*) malloc(aaint[1] * sizeof(double));
257             double* dYGrads = (double*) malloc(aaint[3] * sizeof(double));
258             char** stringVector = NULL;
259
260             // set auto ticks to off
261             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
262             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_AUTO_TICKS__, &autoTicks, jni_bool, 1);
263
264             // Compute X grads
265             dXGrads[0] = drect[0];
266             if (aaint[1] > 1)
267             {
268                 double pas = (drect[1] - drect[0]) / (aaint[1] - 1);
269                 for (i = 0; i < aaint[1]; i++)
270                 {
271                     dXGrads[i] = drect[0] + pas * i;
272                 }
273             }
274
275             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_TICKS_LOCATIONS__, dXGrads, jni_double_vector, aaint[1]);
276
277             // Compute Y grads
278             dYGrads[0] = drect[2];
279             if (aaint[3] > 1)
280             {
281                 double pas = (drect[3] - drect[2]) / (aaint[3] - 1);
282                 for (i = 0; i < aaint[3]; i++)
283                 {
284                     dYGrads[i] = drect[2] + pas * i;
285                 }
286             }
287
288             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_TICKS_LOCATIONS__, dYGrads, jni_double_vector, aaint[3]);
289
290             // Create X Labels
291             stringVector = (char **) malloc(aaint[1] * sizeof(char*));
292             for (i = 0; i < aaint[1]; i++)
293             {
294                 iSize = 6;
295                 if (dXGrads[i] < 0)
296                 {
297                     iSize += 2;
298                 }
299                 dblFabs = fabs(dXGrads[i]);
300                 if (dblFabs >= 10)
301                 {
302                     iSize = iSize + (int)floor(log10(dblFabs));
303                 }
304
305                 stringVector[i] = (char*) malloc(iSize * sizeof(char));
306                 sprintf(stringVector[i], "%.3f", dXGrads[i]);
307                 stringVector[i][iSize - 1] = '\0';
308             }
309
310             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, aaint[1]);
311
312             for (i = 0; i < aaint[1]; i++)
313             {
314                 free(stringVector[i]);
315             }
316
317             free(stringVector);
318             stringVector = NULL;
319
320             // Create Y Labels
321             stringVector = (char**) malloc(aaint[3] * sizeof(char*));
322             for (i = 0; i < aaint[3]; i++)
323             {
324                 iSize = 6;
325                 if (dYGrads[i] < 0)
326                 {
327                     iSize += 2;
328                 }
329                 dblFabs = fabs(dYGrads[i]);
330                 if (dblFabs >= 10)
331                 {
332                     iSize = iSize + (int)floor(log10(dblFabs));
333                 }
334                 stringVector[i] = (char*) malloc(iSize * sizeof(char));
335                 sprintf(stringVector[i], "%.3f", dYGrads[i]);
336                 stringVector[i][iSize - 1] = '\0';
337             }
338
339             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_TICKS_LABELS__, stringVector, jni_string_vector, aaint[3]);
340
341             for (i = 0; i < aaint[3]; i++)
342             {
343                 free(stringVector[i]);
344             }
345
346             free(stringVector);
347             free(dXGrads);
348             free(dYGrads);
349
350             // X and Y subticks
351             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_SUBTICKS__, aaint, jni_int, 1);
352             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_SUBTICKS__, &aaint[2], jni_int, 1);
353
354         }
355         else
356         {
357             sciprint(_("Warning: Nax does not work with logarithmic scaling.\n"));
358         }
359
360     }
361
362     /*---- Drawing the curves and the legends ----*/
363     if (*n1 != 0)
364     {
365         if ((hdltab = MALLOC((*n1 + 1) * sizeof(long))) == NULL)
366         {
367             Scierror(999, _("%s: No more memory.\n"), "plot2d");
368             return -1;
369         }
370         if (with_leg)
371         {
372             /* tabofhandles allocated for legends */
373             if ((tabofhandles = MALLOC((*n1) * sizeof(long long))) == NULL)
374             {
375                 Scierror(999, _("%s: No more memory.\n"), "plot2d");
376                 FREE(hdltab);
377                 return -1;
378             }
379         }
380
381         /*A.Djalel 3D axes */
382         for (jj = 0; jj < *n1; jj++)
383         {
384             char *pobjUID = NULL;
385
386             if (style[jj] > 0)
387             {
388                 BOOL isline = TRUE;
389
390                 if (ptype == 3)
391                 {
392                     isline = FALSE;
393                 }
394                 pobjUID = ConstructPolyline((char*)getCurrentSubWin(), &(x[jj * (*n2)]),
395                                             &(y[jj * (*n2)]), PD0, closeflag, *n2, ptype,
396                                             &style[jj], NULL, NULL, NULL, NULL, isline, FALSE, FALSE, FALSE);
397             }
398             else
399             {
400                 int minusstyle = -style[jj];
401
402                 pobjUID = ConstructPolyline((char*)getCurrentSubWin(), &(x[jj * (*n2)]),
403                                             &(y[jj * (*n2)]), PD0, closeflag, *n2, ptype,
404                                             NULL, NULL, &minusstyle, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
405             }
406             if (pobjUID == NULL)
407             {
408                 // skip
409                 Scierror(999, _("%s: No more memory.\n"), "plot2d");
410             }
411             else
412             {
413                 setCurrentObject(pobjUID);
414
415                 hdl = getHandle(pobjUID);
416                 releaseGraphicObjectProperty(__GO_PARENT__, pobjUID, jni_string, 1);
417                 pobjUID = NULL;
418                 if (with_leg)
419                 {
420                     tabofhandles[cmpt] = hdl;
421                 }
422
423                 hdltab[cmpt] = hdl;
424                 cmpt++;
425             }
426
427         }
428
429         /*---- Drawing the Legends ----*/
430         if (with_leg)
431         {
432             char *legUID;
433             char **Str;
434             int nleg;
435
436             if (scitokenize(legend, &Str, &nleg))
437             {
438                 FREE(tabofhandles);
439                 FREE(hdltab);
440                 Scierror(999, _("%s: No more memory.\n"), "plot2d");
441                 return 0;
442             }
443
444             legUID = ConstructLegend((char*)getCurrentSubWin(), Str, tabofhandles, Min(nleg, cmpt));
445
446             if (legUID != NULL)
447             {
448                 int legendLocation;
449                 int contourMode;
450
451                 /* 9: LOWER_CAPTION */
452                 legendLocation = 9;
453                 setGraphicObjectProperty(legUID, __GO_LEGEND_LOCATION__, &legendLocation, jni_int, 1);
454
455                 contourMode = 0;
456
457                 setGraphicObjectProperty(legUID, __GO_FILL_MODE__, &contourMode, jni_bool, 1);
458                 setGraphicObjectProperty(legUID, __GO_LINE_MODE__, &contourMode, jni_bool, 1);
459             }
460
461             freeArrayOfString(Str, nleg);
462
463             FREE(tabofhandles);
464         }
465
466         /*---- construct Compound ----*/
467         if (cmpt > 0)
468         {
469             int parentVisible = 0;
470             int *piParentVisible = &parentVisible;
471             char* compoundUID = ConstructCompound (hdltab, cmpt);
472             setCurrentObject(compoundUID);
473             setGraphicObjectRelationship(psubwinUID, compoundUID);
474             getGraphicObjectProperty(psubwinUID, __GO_VISIBLE__, jni_bool, (void **)&piParentVisible);
475             setGraphicObjectProperty(compoundUID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
476             releaseGraphicObjectProperty(__GO_PARENT__, compoundUID, jni_string, 1);
477         }
478         FREE(hdltab);
479
480     }
481     /* End of the curves and legend block */
482
483     return (0);
484 }
485
486 /* Given two set of coordinates x and y this routine computes the corresponding
487  *  data bounds rectangle drect=[xmin,ymin,xmax,ymax] taking into account the logflag
488  *  -> means we have to find among the data the min > 0.
489  */
490 void compute_data_bounds2(int cflag, char dataflag, char *logflags, double *x, double *y, int n1, int n2, double *drect)
491 {
492     int size_x = 0, size_y = 0;
493     double xd[2];
494     double *x1 = NULL;
495
496     switch (dataflag)
497     {
498         case 'e':
499             xd[0] = 1.0;
500             xd[1] = (double)n2;
501             x1 = xd;
502             size_x = (n2 != 0) ? 2 : 0;
503             break;
504         case 'o':
505             x1 = x;
506             size_x = n2;
507             break;
508         case 'g':
509         default:
510             x1 = x;
511             size_x = (cflag == 1) ? n1 : (n1 * n2);
512             break;
513     }
514
515     if (size_x != 0)
516     {
517         if (logflags[0] != 'l')
518         {
519             drect[0] = Mini(x1, size_x);
520             drect[1] = Maxi(x1, size_x);
521         }
522         else
523         {
524             /* log. case */
525             drect[0] = sciFindStPosMin(x1, size_x);
526             drect[1] = Maxi(x1, size_x);
527         }
528
529     }
530     else
531     {
532         if (logflags[0] != 'l')
533         {
534             drect[0] = 0.0;
535             drect[1] = 10.0;
536         }
537         else
538         {
539             /* log. case */
540             drect[0] = 1.0;
541             drect[1] = 10.0;
542         }
543     }
544
545     size_y = (cflag == 1) ? n2 : (n1 * n2);
546     if (size_y != 0)
547     {
548         if (logflags[1] != 'l')
549         {
550             drect[2] = Mini(y, size_y);
551             drect[3] = Maxi(y, size_y);
552         }
553         else
554         {
555             /* log. case */
556             drect[2] = sciFindStPosMin(y, size_y);
557             drect[3] = Maxi(y, size_y);
558         }
559
560     }
561     else
562     {
563         if (logflags[1] != 'l')
564         {
565             drect[2] = 0.0;
566             drect[3] = 10.0;
567         }
568         else
569         {
570             /* log. case */
571             drect[2] = 1.0;
572             drect[3] = 10.0;
573         }
574     }
575     /* back to default values for  x=[] and y = [] */
576     if (drect[2] == LARGEST_REAL)
577     {
578         drect[2] = 0.0;
579         drect[3] = 10.0;
580     }
581     if (drect[0] == LARGEST_REAL)
582     {
583         drect[0] = 0.0;
584         drect[1] = 10.0;
585     }
586
587 }
588
589 BOOL update_specification_bounds(char *psubwinUID, double rect[6], int flag)
590 {
591     double *dataBounds = NULL;
592
593     /*
594      * 2D: keep the existing zmin and zmax
595      * which is why they must be fetched
596      */
597     if (flag != 3)
598     {
599         getGraphicObjectProperty(psubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
600
601         rect[4] = dataBounds[4];
602         rect[5] = dataBounds[5];
603     }
604
605     setGraphicObjectProperty(psubwinUID, __GO_DATA_BOUNDS__, rect, jni_double_vector, 6);
606
607     return TRUE;
608 }
609
610 /* F.Leray */
611 /* brect must have the same format as drect i.e.: [xmin,xmax,ymin,ymax] */
612 /* brect = INPUT ; drect = OUTPUT (warning drect is dim 6) */
613 int re_index_brect(double *brect, double *drect)
614 {
615     drect[0] = brect[0];
616     drect[1] = brect[2];
617     drect[2] = brect[1];
618     drect[3] = brect[3];
619
620     return 0;
621 }
622
623 /* F.Leray 07.05.04 */
624 /* Dispatch info contained in strflag to all the flag available in
625    sciSubwin object (tight_limits, isoview, isaxes...) */
626 /*
627  * This function has been adapted to the MVC framework
628  */
629 BOOL strflag2axes_properties(char *psubwinUID, char *strflag)
630 {
631     BOOL haschanged = FALSE;
632     BOOL tightLimitsPrev = FALSE;
633     BOOL isoviewPrev = FALSE;
634     int boxPrev = 0;
635     int tightLimits = 0;
636     int firstPlot = 0;
637     int axisVisible = 0;
638     int boxType = 0;
639     int xLocationPrev = 0;
640     int yLocationPrev = 0;
641     int xLocation = 0;
642     int yLocation = 0;
643     int isoview = 0;
644     int axesVisiblePrev[3];
645     int axesVisible[3];
646
647     int iTmp = 0;
648     int *piTmp = &iTmp;
649
650     getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, jni_bool, (void **)&piTmp);
651     axesVisiblePrev[0] = iTmp;
652     getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, jni_bool, (void **)&piTmp);
653     axesVisiblePrev[1] = iTmp;
654     getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, jni_bool, (void **)&piTmp);
655     axesVisiblePrev[2] = iTmp;
656
657     getGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, jni_int, (void**)&piTmp);
658     boxPrev = iTmp;
659
660     getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOCATION__, jni_int, (void**)&piTmp);
661     xLocationPrev = iTmp;
662     getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOCATION__, jni_int, (void**)&piTmp);
663     yLocationPrev = iTmp;
664
665     getGraphicObjectProperty(psubwinUID, __GO_TIGHT_LIMITS__, jni_bool, (void **)&piTmp);
666     tightLimitsPrev = iTmp;
667     getGraphicObjectProperty(psubwinUID, __GO_ISOVIEW__, jni_bool, (void **)&piTmp);
668     isoviewPrev = iTmp;
669
670     /* F.Leray 07.05.04 */
671     /* strflag[1] Isoview & tight_limits flags management */
672     switch (strflag[1])
673     {
674         case '0':
675         case '9':
676             /* no changes */
677             break;
678         case '1':
679         case '2':
680         case '7':
681         case '8':
682             tightLimits = 1;
683             setGraphicObjectProperty(psubwinUID, __GO_TIGHT_LIMITS__, &tightLimits, jni_bool, 1);
684             break;
685         case '3':
686         case '4':
687             isoview = 1;
688             setGraphicObjectProperty(psubwinUID, __GO_ISOVIEW__, &isoview, jni_bool, 1);
689             break;
690         case '5':
691         case '6':
692             /* pretty axes */
693             tightLimits = 0;
694             setGraphicObjectProperty(psubwinUID, __GO_TIGHT_LIMITS__, &tightLimits, jni_bool, 1);
695             break;
696     }
697
698     /* F.Leray 07.05.04 */
699     /* strflag[2] */
700     switch (strflag[2])
701     {
702
703         case '0':
704             getGraphicObjectProperty(psubwinUID, __GO_FIRST_PLOT__, jni_bool, (void **)&piTmp);
705             firstPlot = iTmp;
706
707             if (firstPlot)
708             {
709                 axisVisible = 0;
710                 /* 0: OFF */
711                 boxType = 0;
712
713                 setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
714                 setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
715                 /* also trigger z axis */
716                 setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
717                 setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
718             }
719             /*else no changes : the isaxes properties is driven by the previous plot */
720             break;
721         case '1':
722             axisVisible = 1;
723             /* 1: ON */
724             boxType = 1;
725             /* 4: LEFT */
726             yLocation = 4;
727
728             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
729             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
730             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
731             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
732             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
733
734             break;
735         case '2':
736             axisVisible = 0;
737             boxType = 1;
738
739             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
740             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
741             /* also trigger z axis */
742             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
743             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
744
745             break;
746         case '3':
747             axisVisible = 1;
748             boxType = 0;
749             /* 5: RIGHT */
750             yLocation = 5;
751
752             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
753             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
754             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
755             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
756             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
757
758             break;
759         case '4':
760             axisVisible = 1;
761             /* 2: MIDDLE */
762             xLocation = 2;
763             yLocation = 2;
764             boxType = 0;
765
766             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
767             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
768             /* also trigger z axis */
769             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
770             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOCATION__, &xLocation, jni_int, 1);
771             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
772             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
773
774             break;
775         case '5':
776             axisVisible = 1;
777             xLocation = 2;
778             yLocation = 2;
779             boxType = 1;
780
781             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
782             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
783             /* also trigger z axis */
784             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
785             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOCATION__, &xLocation, jni_int, 1);
786             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOCATION__, &yLocation, jni_int, 1);
787             setGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, &boxType, jni_int, 1);
788
789             break;
790         case '9':
791             axisVisible = 1;
792
793             setGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
794             setGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
795             /* also trigger z axis */
796             setGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, &axisVisible, jni_bool, 1);
797     }
798
799     getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_VISIBLE__, jni_bool, (void **)&piTmp);
800     axesVisible[0] = iTmp;
801     getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_VISIBLE__, jni_bool, (void **)&piTmp);
802     axesVisible[1] = iTmp;
803     getGraphicObjectProperty(psubwinUID, __GO_Z_AXIS_VISIBLE__, jni_bool, (void **)&piTmp);
804     axesVisible[2] = iTmp;
805
806     getGraphicObjectProperty(psubwinUID, __GO_BOX_TYPE__, jni_int, (void**)&piTmp);
807     boxType = iTmp;
808
809     getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOCATION__, jni_int, (void**)&piTmp);
810     xLocation = iTmp;
811     getGraphicObjectProperty(psubwinUID, __GO_Y_AXIS_LOCATION__, jni_int, (void**)&piTmp);
812     yLocation = iTmp;
813
814     getGraphicObjectProperty(psubwinUID, __GO_TIGHT_LIMITS__, jni_bool, (void **)&piTmp);
815     tightLimits = iTmp;
816     getGraphicObjectProperty(psubwinUID, __GO_ISOVIEW__, jni_bool, (void **)&piTmp);
817     isoview = iTmp;
818
819     /* Find if something has changed */
820     if (axesVisible[0] != axesVisiblePrev[0]
821             || axesVisible[1] != axesVisiblePrev[1]
822             || axesVisible[2] != axesVisiblePrev[2]
823             || xLocation != xLocationPrev || yLocation != yLocationPrev || boxType != boxPrev || tightLimits != tightLimitsPrev || isoview != isoviewPrev)
824     {
825         haschanged = TRUE;
826     }
827     else
828     {
829         haschanged = FALSE;
830     }
831
832     return haschanged;
833 }