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 }