scilab/modules/graphics/src/c/sciCall.c

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