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.1-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 #include "Format.h"
  50 #include "deleteGraphicObject.h"
  51
  52 /** Update data bounds according to the given data bound passed in rect */
  53 static void updateXYDataBounds(int iSubwinUID, double rect[6]);
  54 static void updateXYZDataBounds(int iSubwinUID, double rect[6]);
  55
  56 /*------------------------------------------------
  57  * Objrect :
  58  * On recupere la figure courante, puis on recupere la sous fenetre qui y est selectionnee
  59  *   puis on contruit le rectangle, qu on le place comme objet courant
  60  * ensuite il reste qu'appeler la fonction du dessin de l'objet
  61  *-----------------------------------------------*/
  62
  63 void Objrect (double* x         ,
  64               double* y         ,
  65               double* width     ,
  66               double* height    ,
  67               int    * foreground,
  68               int    * background,
  69               BOOL     isfilled  ,
  70               BOOL     isline    ,
  71               long   * hdl )
  72 {
  73     int iNewObjUID = 0;
  74     int iSubwinUID = 0;
  75     double rect[6];
  76
  77     iSubwinUID = getCurrentSubWin();
  78
  79     /* check if the auto_clear property is on and then erase everything */
  80     checkRedrawing();
  81
  82     rect[0] = *x;
  83     rect[1] = *x + *width;
  84     rect[2] = *y - *height;
  85     rect[3] = *y;
  86
  87     updateXYDataBounds(iSubwinUID, rect);
  88
  89     /*newObjUID = ConstructRectangle(iSubwinUID , *x, *y, *height, *width,
  90       foreground, background, isfilled, isline);*/
  91
  92     iNewObjUID = createRect(iSubwinUID, *x, *y, *height, *width,
  93                             foreground == NULL ? -1 : *foreground,
  94                             background == NULL ? -1 : *background,
  95                             (int)isfilled, (int)isline);
  96
  97     if (iNewObjUID == 0)
  98     {
  99         /* an error occurred */
 100         *hdl = -1;
 101         return;
 102     }
 103
 104     setCurrentObject(iNewObjUID);
 105     *hdl = getHandle(iNewObjUID);
 106 }
 107
 108
 109 /*----------------------------------------------
 110  * Objarc :
 111  *-----------------------------------------------*/
 112
 113 void Objarc(double* angle1    ,
 114             double* angle2    ,
 115             double* x         ,
 116             double* y         ,
 117             double* width     ,
 118             double* height    ,
 119             int    * foreground,
 120             int    * background,
 121             BOOL     isfilled  ,
 122             BOOL     isline    ,
 123             long   * hdl  )
 124 {
 125     int iSubwinUID = 0;
 126     int iObjUID = 0;
 127     double rect[6];
 128     const double two_pi = 2 * M_PI;
 129
 130     iSubwinUID = getCurrentSubWin();
 131     checkRedrawing();
 132
 133     if (abs(*angle2) >= two_pi)
 134     {
 135         rect[0] = *x;
 136         rect[1] = *x + *width;
 137         rect[2] = *y - *height;
 138         rect[3] = *y;
 139     }
 140     else
 141     {
 142         double a = *angle1;
 143         double s = *angle2;
 144         double a1, b1;
 145         double b;
 146
 147         a -= (floor(a / two_pi)) * two_pi;
 148         b = a + s;
 149
 150         if (s >= 0)
 151         {
 152             b = a + s;
 153         }
 154         else
 155         {
 156             b = a;
 157             a += s;
 158         }
 159
 160         b1 = b / M_PI;
 161         a1 = a / M_PI;
 162
 163         // is there a 2k\pi in [a,b] ?
 164         if (ceil(a1 / 2) <= floor(b1 / 2))
 165         {
 166             rect[1] = *x + *width;
 167         }
 168         else
 169         {
 170             rect[1] = *x + 0.5 * *width * (1 + Max(cos(a), cos(b)));
 171         }
 172
 173         // is there a (2k+1)\pi in [a,b] ?
 174         if (ceil((a1 - 1) / 2) <= floor((b1 - 1) / 2))
 175         {
 176             rect[0] = *x;
 177         }
 178         else
 179         {
 180             rect[0] = *x + 0.5 * *width * (1 + Min(cos(a), cos(b)));
 181         }
 182
 183         // is there a (2k+1/2)\pi in [a,b] ?
 184         if (ceil((a1 - 0.5) / 2) <= floor((b1 - 0.5) / 2))
 185         {
 186             rect[3] = *y;
 187         }
 188         else
 189         {
 190             rect[3] = *y + 0.5 * *height * (-1 + Max(sin(a), sin(b)));
 191         }
 192
 193         // is there a (2k+3/2)\pi in [a,b] ?
 194         if (ceil((a1 - 1.5) / 2) <= floor((b1 - 1.5) / 2))
 195         {
 196             rect[2] = *y - *height;
 197         }
 198         else
 199         {
 200             rect[2] = *y + 0.5 * *height * (-1 + Min(sin(a), sin(b)));
 201         }
 202     }
 203
 204     updateXYDataBounds(iSubwinUID, rect);
 205
 206     iObjUID = createArc(iSubwinUID, *x, *y,
 207                         *height, *width, *angle1, *angle2, foreground, background, isfilled, isline);
 208
 209     setCurrentObject(iObjUID);
 210     *hdl = getHandle(iObjUID);
 211 }
 212
 213 /*------------------------------------------------
 214  * Objpoly :
 215  *-----------------------------------------------*/
 216
 217 void Objpoly (double  * x     ,
 218               double  * y     ,
 219               int   n     ,
 220               int   closed,
 221               int       mark  ,
 222               long    * hdl)
 223 {
 224     int iSubwinUID = 0;
 225     int iObjUID = 0;
 226     double rect[6];
 227
 228     iSubwinUID = getCurrentSubWin();
 229
 230     checkRedrawing();
 231
 232     if (n)
 233     {
 234         MiniMaxi(x, n, rect, rect + 1);
 235         MiniMaxi(y, n, rect + 2, rect + 3);
 236
 237         updateXYDataBounds(iSubwinUID, rect);
 238     }
 239
 240     if (mark <= 0)
 241     {
 242         int absmark = abs(mark);
 243         iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n, 1,
 244                                     NULL, NULL, &absmark, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
 245     }
 246     else
 247     {
 248         iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n, 1,
 249                                     &mark, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
 250     }
 251
 252     if (iObjUID == NULL)
 253     {
 254         Scierror(999, _("%s: No more memory.\n"), "Objpoly");
 255         return;
 256     }
 257
 258     setCurrentObject(iObjUID);
 259     *hdl = getHandle(iObjUID);
 260 }
 261
 262
 263 /*------------------------------------------------
 264  * Objfpoly :
 265  *-----------------------------------------------*/
 266
 267 void Objfpoly (double  * x    ,
 268                double  * y    ,
 269                int   n    ,
 270                int * style,
 271                long    * hdl  ,
 272                int   shading)
 273 {
 274     int iSubwinUID = 0;
 275     int iObjUID = 0;
 276
 277     int fillcolor = 0;
 278     int contourcolor = 0;
 279     int *piContourColor = &contourcolor;
 280
 281     int closed = 1; /* we close the polyline by default */
 282     double rect[6];
 283
 284     iSubwinUID = getOrCreateDefaultSubwin();
 285
 286     checkRedrawing();
 287
 288     if (n)
 289     {
 290         MiniMaxi(x, n, rect, rect + 1);
 291         MiniMaxi(y, n, rect + 2, rect + 3);
 292
 293         updateXYDataBounds(iSubwinUID, rect);
 294     }
 295
 296     if (shading == 2)
 297     {
 298         /* interpolated shading is "on" */
 299         iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n,
 300                                     1, NULL, style, NULL, NULL, NULL, FALSE, TRUE, FALSE, TRUE);
 301     }
 302     else
 303     {
 304
 305         /* flat mode is "on" */
 306         if (*style < 0)
 307         {
 308             fillcolor = abs(*style);
 309             iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n,
 310                                         1, NULL, &fillcolor, NULL, NULL, NULL, FALSE, TRUE, FALSE, FALSE);
 311         }
 312         else if (*style == 0)
 313         {
 314             getGraphicObjectProperty(iSubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piContourColor);
 315             iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n,
 316                                         1, &contourcolor, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
 317         }
 318         else
 319         {
 320             /* *style > 0*/
 321             fillcolor = *style;
 322             getGraphicObjectProperty(iSubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piContourColor);
 323             iObjUID = ConstructPolyline(iSubwinUID, x, y, PD0, closed, n,
 324                                         1, &contourcolor, &fillcolor, NULL, NULL, NULL, TRUE, TRUE, FALSE, FALSE);
 325         }
 326
 327     }
 328
 329     if (iObjUID == NULL)
 330     {
 331         Scierror(999, _("%s: No more memory.\n"), "Objfpoly");
 332         return;
 333     }
 334
 335     setCurrentObject(iObjUID);
 336     *hdl = getHandle(iObjUID);
 337 }
 338
 339
 340 /*-----------------------------------------------------------
 341  *   Objsegs :
 342  *-----------------------------------------------------------*/
 343 void Objsegs (int * style,
 344               int   flag ,
 345               int   n1   ,
 346               double  * x    ,
 347               double  * y    ,
 348               double  * z    ,
 349               double    arsize)
 350 {
 351     int iObjUID = 0;
 352     int iSubwinUID = 0;
 353     int type = 0, colored = 0;
 354     double *fx = NULL, *fy = NULL; // No fx or fy
 355     int typeofchamp = -1; /* no champ here, only segs ; this info is useless */
 356     double rect[6];
 357
 358     checkRedrawing();
 359     iSubwinUID = getCurrentSubWin();
 360
 361     if (n1)
 362     {
 363         MiniMaxi(x, n1, rect, rect + 1);
 364         MiniMaxi(y, n1, rect + 2, rect + 3);
 365
 366         if (z)
 367         {
 368             MiniMaxi(z, n1, rect + 4, rect + 5);
 369             updateXYZDataBounds(iSubwinUID, rect);
 370         }
 371         else
 372         {
 373             updateXYDataBounds(iSubwinUID, rect);
 374         }
 375     }
 376
 377     iObjUID = createSegs(iSubwinUID, x, n1, y, n1, z, (z == NULL ? 0 : n1), style, flag == 0 ? 1 : n1, arsize);
 378
 379     if (iObjUID == NULL)
 380     {
 381         Scierror(999, _("%s: No more memory.\n"), "Objsegs");
 382         return;
 383     }
 384
 385     setCurrentObject(iObjUID);
 386 }
 387 /*-----------------------------------------------------------
 388  * Objstring:
 389  *-----------------------------------------------------------*/
 390
 391 /* box is an OUTPUT re-used inside matdes.c in scixstring */
 392 void Objstring(char            ** fname      ,
 393                int                nbRow      ,
 394                int                nbCol      ,
 395                double             x          ,
 396                double             y          ,
 397                double           * angle      ,
 398                double             box[4]     ,
 399                BOOL               autoSize   ,
 400                double             userSize[2],
 401                long             * hdl        ,
 402                int                centerPos  ,
 403                int              * foreground ,
 404                int              * background ,
 405                BOOL               isboxed    ,
 406                BOOL               isline     ,
 407                BOOL               isfilled   ,
 408                sciTextAlignment   alignment)
 409 {
 410     int iSubwinUID = 0;
 411     int iObjUID = 0;
 412
 413     iSubwinUID = getCurrentSubWin();
 414
 415     checkRedrawing();
 416
 417     iObjUID = ConstructText(iSubwinUID   ,
 418                             fname     ,
 419                             nbRow     ,
 420                             nbCol     ,
 421                             x         ,
 422                             y         ,
 423                             autoSize  ,
 424                             userSize  ,
 425                             centerPos ,
 426                             foreground,
 427                             background,
 428                             isboxed   ,
 429                             isline    ,
 430                             isfilled  ,
 431                             alignment);
 432
 433     if (iObjUID == NULL)
 434     {
 435         Scierror(999, _("%s: No more memory.\n"), "Objstring");
 436         return;
 437     }
 438
 439     *hdl = getHandle(iObjUID);
 440
 441     setGraphicObjectProperty(iObjUID, __GO_FONT_ANGLE__, angle, jni_double, 1);
 442 }
 443
 444
 445 /*------------------------------------------------
 446  *  plot2d
 447  *-----------------------------------------------*/
 448
 449 void Objplot2d (int       ptype     ,
 450                 char      logflags[],
 451                 double    x[]       ,
 452                 double    y[]       ,
 453                 int * n1        ,
 454                 int * n2        ,
 455                 int   style[]   ,
 456                 char      strflag[] ,
 457                 char      legend[]  ,
 458                 double    brect[]   ,
 459                 int   aaint[]   ,
 460                 BOOL      flagNax)
 461 {
 462     plot2dn(ptype, logflags, x, y, n1, n2, style, strflag, legend, brect, aaint, flagNax, 4L, bsiz);
 463 }
 464
 465 /*------------------------------------------------
 466  *  grayplot
 467  *-----------------------------------------------*/
 468 void Objgrayplot (double    x[]      ,
 469                   double    y[]      ,
 470                   double    z[]      ,
 471                   int * n1       ,
 472                   int * n2       ,
 473                   char      strflag[],
 474                   double    brect[]  ,
 475                   int   aaint[]  ,
 476                   BOOL      flagNax,
 477                   char logflag[])
 478 {
 479     C2F(xgray)(x, y, z, n1, n2, strflag, brect, aaint, flagNax, logflag, bsiz);
 480 }
 481
 482 /*------------------------------------------------
 483  *  Matplot
 484  *-----------------------------------------------*/
 485 void Objmatplot (double    z[]      ,
 486                  int * n1       ,
 487                  int * n2       ,
 488                  char      strflag[],
 489                  double    brect[]  ,
 490                  int    aaint[]  ,
 491                  BOOL      flagNax)
 492 {
 493     C2F(xgray1)(z, n1, n2, strflag, brect, aaint, flagNax, bsiz);
 494 }
 495
 496 void ObjmatplotImage (void * z      ,
 497                       int * n1       ,
 498                       int * n2       ,
 499                       char      strflag[],
 500                       double    brect[]  ,
 501                       int    aaint[]  ,
 502                       BOOL      flagNax,
 503                       int plottype)
 504 {
 505     if (plottype == -1)
 506     {
 507         C2F(xgray1)((double *)z, n1, n2, strflag, brect, aaint, flagNax, bsiz);
 508     }
 509     else
 510     {
 511         C2F(implot)((unsigned char *)z, n1, n2, strflag, brect, aaint, flagNax, bsiz, plottype);
 512     }
 513 }
 514
 515 /*------------------------------------------------
 516  *  Matplot1
 517  *-----------------------------------------------*/
 518 void Objmatplot1 (double    z[],
 519                   int * n1 ,
 520                   int * n2 ,
 521                   double xrect[], int plottype)
 522 {
 523     if (plottype == -1)
 524     {
 525         C2F(xgray2)(z, n1, n2, xrect);
 526     }
 527     else
 528     {
 529         C2F(implot1)((unsigned char *)z, n1, n2, xrect, plottype);
 530     }
 531 }
 532
 533 /*------------------------------------------------
 534  *  plot3d
 535  *-----------------------------------------------*/
 536 void Objplot3d (char    * fname ,
 537                 int * isfac ,
 538                 int * izcol ,
 539                 double    x[]   ,
 540                 double    y[]   ,
 541                 double    z[]   ,
 542                 double  * zcol  ,
 543                 int * m     ,
 544                 int * n     ,
 545                 double  * theta ,
 546                 double  * alpha ,
 547                 char    * legend,
 548                 int * iflag ,
 549                 double  * ebox  ,
 550                 int * m1    , /*Adding F.Leray 12.03.04 and 19.03.04*/
 551                 int * n1    ,
 552                 int * m2    ,
 553                 int * n2    ,
 554                 int * m3    ,
 555                 int * n3    ,
 556                 int * m3n   ,
 557                 int * n3n)
 558 /* F.Leray 25.04.05 : warning here legends means "X@Y@Z": it is labels writings!! */
 559 /* legends has not the same meaning than inside plot2dn (there, it is really the legends of the plotted curves)*/
 560 {
 561     sciTypeOf3D typeof3d;
 562     int flagcolor = 0;
 563     int* pObj = NULL;
 564     int i = 0;
 565
 566     int iSubwinUID = 0;
 567
 568     int firstPlot = 0;
 569
 570     int clipState = 0;
 571
 572     int iNewSurfaceUID = 0;
 573
 574
 575     /* =================================================
 576      * Force SubWindow properties according to arguments
 577      * ================================================= */
 578
 579     iSubwinUID = getCurrentSubWin();
 580     checkRedrawing();
 581     initSubWinTo3d(iSubwinUID, legend, iflag, *alpha, *theta, ebox, x, *m1 **n1, y, *m2 **n2, z, *m3 **n3);
 582
 583     /* =================================================
 584      * Analyze arguments to find entity type
 585      * ================================================= */
 586
 587     if (*isfac == 1)
 588     {
 589         if (*izcol == 0)
 590         {
 591             if (strcmp(fname, "plot3d1") == 0)
 592             {
 593                 typeof3d = SCI_FAC3D;
 594                 flagcolor = 1;
 595             }
 596             else
 597             {
 598                 typeof3d = SCI_FAC3D;
 599                 flagcolor = 0;
 600             }
 601         }
 602         else if (*izcol == 2)
 603         {
 604             typeof3d = SCI_FAC3D;
 605             flagcolor = 3;
 606         }
 607         else
 608         {
 609             typeof3d = SCI_FAC3D;
 610             flagcolor = 2;
 611         }
 612     }
 613     else if (*isfac == 0)
 614     {
 615         if (strcmp(fname, "plot3d1") == 0)
 616         {
 617             typeof3d = SCI_PLOT3D;
 618             flagcolor = 1;
 619         }
 620         else
 621         {
 622             typeof3d = SCI_PLOT3D;
 623             flagcolor = 0;
 624         }
 625     }
 626     else
 627     {
 628         typeof3d = SCI_PARAM3D1;
 629         flagcolor = 1;
 630     }
 631
 632     /* =================================================
 633      * Construct the Entities
 634      * ================================================= */
 635
 636     /*Distinction here between SCI_PARAM3D1 and others*/
 637     if (typeof3d != SCI_PARAM3D1)
 638     {
 639         int dimvectx = -1;
 640         int dimvecty = -1;
 641         if (*isfac == 1)
 642         {
 643             /* x is considered as a matrix */
 644             dimvectx = -1;
 645         }
 646         else if (*m1 == 1) /* x is a row vector */
 647         {
 648             dimvectx = *n1;
 649         }
 650         else if (*n1 == 1) /* x is a column vector */
 651         {
 652             dimvectx = *m1;
 653         }
 654         else /* x is a matrix */
 655         {
 656             dimvectx = -1;
 657         }
 658
 659         if (dimvectx > 1)
 660         {
 661             int monotony = checkMonotony(x, dimvectx);
 662             if (monotony == 0)
 663             {
 664                 Scierror(999, _("%s: x vector is not monotonous.\n"), "Objplot3d");
 665                 return;
 666             }
 667
 668         }
 669
 670         if (*isfac == 1)
 671         {
 672             /* y is considered as a matrix */
 673             dimvecty = -1;
 674         }
 675         else if (*m2 == 1) /* y is a row vector */
 676         {
 677             dimvecty = *n2;
 678         }
 679         else if (*n2 == 1) /* y is a column vector */
 680         {
 681             dimvecty = *m2;
 682         }
 683         else /* y is a matrix */
 684         {
 685             dimvecty = -1;
 686         }
 687
 688         if (dimvecty > 1)
 689         {
 690             /* test the monotony on y*/
 691             int monotony = checkMonotony(y, dimvecty);
 692             if (monotony == 0)
 693             {
 694                 Scierror(999, _("%s: y vector is not monotonous.\n"), "Objplot3d");
 695                 return;
 696             }
 697         }
 698
 699         iNewSurfaceUID = ConstructSurface(iSubwinUID, typeof3d,
 700                                           x, y, z, zcol, *izcol, *m, *n, iflag, ebox, flagcolor,
 701                                           isfac, m1, n1, m2, n2, m3, n3, m3n, n3n);
 702
 703         if (iNewSurfaceUID == 0)
 704         {
 705             Scierror(999, _("%s: No more memory.\n"), "Objplot3d");
 706             return;
 707         }
 708
 709         setCurrentObject(iNewSurfaceUID);
 710
 711         /* Force clipping, 1: CLIPGRF */
 712         clipState = 1;
 713         setGraphicObjectProperty(iNewSurfaceUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
 714     }
 715     else
 716     {
 717         int iNewPolylineUID = 0;
 718         int iCurrentSubwinUID = 0;
 719
 720         if ((pObj = (int*)MALLOC (*n * sizeof (int))) == NULL)
 721         {
 722             Scierror(999, "%s: No more memory.\n", fname);
 723             return;
 724         }
 725
 726         iCurrentSubwinUID = getCurrentSubWin();
 727
 728         for (i = 0; i < *n; ++i)
 729         {
 730             if ((*n > 0) && (zcol != (double *)NULL))
 731             {
 732                 if ((int) zcol[i] > 0)
 733                 {
 734                     int intzcol = (int) zcol[i];
 735                     iNewPolylineUID = ConstructPolyline
 736                                       (iCurrentSubwinUID,
 737                                        &(x[*m * i]), &(y[*m * i]), &(z[*m * i]), 0, *m, 1,
 738                                        &intzcol, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
 739                 }
 740                 else
 741                 {
 742                     int intzcol = (int) - zcol[i];
 743                     iNewPolylineUID = ConstructPolyline
 744                                       (iCurrentSubwinUID,
 745                                        &(x[*m * i]), &(y[*m * i]), &(z[*m * i]), 0, *m, 1,
 746                                        NULL, NULL, &intzcol, NULL, NULL, FALSE, FALSE, TRUE, FALSE);
 747                 }
 748             }
 749             else
 750             {
 751                 /* default case, nothing is given */
 752                 int curcolor = 0;
 753                 int *piCurColor = &curcolor;
 754
 755                 getGraphicObjectProperty(iCurrentSubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piCurColor);
 756
 757                 iNewPolylineUID = ConstructPolyline(iCurrentSubwinUID,
 758                                                     &(x[*m * i]), &(y[*m * i]), &(z[*m * i]), 0, *m, 1,
 759                                                     &curcolor, NULL, NULL, NULL, NULL, TRUE, FALSE, FALSE, FALSE);
 760             }
 761
 762             if (iNewPolylineUID == 0)
 763             {
 764                 Scierror(999, _("%s: No more memory.\n"), fname);
 765                 FREE(pObj);
 766                 return;
 767             }
 768
 769             setCurrentObject(iNewPolylineUID);
 770             setGraphicObjectRelationship(iCurrentSubwinUID, iNewPolylineUID);
 771
 772             /* Force clipping, 1: CLIPGRF */
 773             clipState = 1;
 774             setGraphicObjectProperty(iNewPolylineUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
 775
 776             pObj[i] = iNewPolylineUID;
 777         }
 778
 779         /** construct Compound and make it current object**/
 780         if (*n > 1)
 781         {
 782             int o = createCompound (iCurrentSubwinUID, pObj, *n);
 783             setCurrentObject(o);
 784         }
 785         FREE(pObj);
 786     }
 787
 788     /* =================================================
 789      * Redraw Figure
 790      * ================================================= */
 791
 792     // subwin has been modified
 793
 794     firstPlot = 0;
 795     setGraphicObjectProperty(iSubwinUID, __GO_FIRST_PLOT__, &firstPlot, jni_bool, 1);
 796 }
 797 /*-----------------------------------------------------------
 798  * Objaxis:
 799  *-----------------------------------------------------------*/
 800
 801 void Objdrawaxis (char     dir    ,
 802                   char     tics   ,
 803                   double* x      ,
 804                   int    * nx     ,
 805                   double* y      ,
 806                   int    * ny     ,
 807                   char   * val[]  ,
 808                   int      subint ,
 809                   char   * format ,
 810                   int      font   ,
 811                   int      textcol,
 812                   int      ticscol,
 813                   char     flag   ,
 814                   int      seg    ,
 815                   int      nb_tics_labels)
 816 {
 817     int iObjUID = 0;
 818     int iSubwinUID = 0;
 819     int ticksDirection = 0;
 820     int ticksStyle = 0;
 821
 822     iSubwinUID = getCurrentSubWin();
 823
 824     checkRedrawing();
 825
 826     switch (dir)
 827     {
 828         default :
 829         case 'u' :
 830             ticksDirection = 0;
 831             break;
 832         case 'd' :
 833             ticksDirection = 1;
 834             break;
 835         case 'l' :
 836             ticksDirection = 2;
 837             break;
 838         case 'r' :
 839             ticksDirection = 3;
 840             break;
 841     }
 842
 843     switch (tics)
 844     {
 845         default:
 846         case 'v':
 847             ticksStyle = 0;
 848             break;
 849         case 'r':
 850             ticksStyle = 1;
 851             break;
 852         case 'i':
 853             ticksStyle = 2;
 854             break;
 855     }
 856
 857     iObjUID = createAxis(iSubwinUID, ticksDirection, ticksStyle, x, *nx, y, *ny, subint, format, font, textcol, ticscol, seg);
 858
 859     if (iObjUID == NULL)
 860     {
 861         Scierror(999, _("%s: No more memory.\n"), "Objdrawaxis");
 862         return;
 863     }
 864
 865     if (val == NULL)
 866     {
 867         char **matData;
 868         StringMatrix *tics_labels;
 869
 870         tics_labels = computeDefaultTicsLabels(iObjUID);
 871
 872         if (tics_labels == NULL)
 873         {
 874             deleteGraphicObject(iObjUID);
 875             return;
 876         }
 877
 878         matData = getStrMatData(tics_labels);
 879
 880         /*
 881          * The labels vector size must be computed using the matrix's dimensions.
 882          * To be modified when the labels computation is moved to the Model.
 883          */
 884         setGraphicObjectProperty(iObjUID, __GO_TICKS_LABELS__, matData, jni_string_vector, tics_labels->nbCol * tics_labels->nbRow);
 885
 886         deleteMatrix(tics_labels);
 887     }
 888     else
 889     {
 890         int i = 0;
 891         /*
 892          * Labels are set using the str argument; the previous code tested whether each element of the
 893          * str array was null and set the corresponding Axis' element to NULL, though there was no
 894          * apparent reason to do so. This is still checked, but now aborts building the Axis.
 895          */
 896
 897         if (nb_tics_labels == -1)
 898         {
 899             Scierror(999, _("Impossible case when building axis\n"));
 900             deleteGraphicObject(iObjUID);
 901             return;
 902         }
 903
 904         for (i = 0; i < nb_tics_labels; i++)
 905         {
 906             if (val[i] == NULL)
 907             {
 908                 deleteGraphicObject(iObjUID);
 909                 return;
 910             }
 911         }
 912
 913         setGraphicObjectProperty(iObjUID, __GO_TICKS_LABELS__, val, jni_string_vector, nb_tics_labels);
 914     }
 915
 916     setCurrentObject(iObjUID);
 917 }
 918
 919 /*-----------------------------------------------------------
 920  * Objnumb:
 921  *-----------------------------------------------------------*/
 922
 923 void Objnumb(char          * fname    ,
 924              unsigned long   fname_len,
 925              int         n        ,
 926              int         flag     ,
 927              double          x        ,
 928              double          y        ,
 929              double        * angle    ,
 930              double        * box )
 931 {
 932     /*** faire une macro scilab sur xstring ****/
 933
 934
 935 }
 936
 937 /*------------------------------------------------
 938  * fec
 939  *-----------------------------------------------*/
 940 void Objfec (double    x[]        ,
 941              double    y[]        ,
 942              double    noeud[]    ,
 943              double  * fun        ,
 944              int * n          ,
 945              int * m          ,
 946              char      strflag[]  ,
 947              char      legend[]   ,
 948              double    brect[]    ,
 949              int   aaint[]    ,
 950              double    Zminmax[]  ,
 951              int   Colminmax[],
 952              int   ColOut[]   ,
 953              BOOL      WithMesh   ,
 954              BOOL      flagNax)
 955 {
 956     C2F(fec)(x, y, noeud, fun, n, m, strflag, legend, brect, aaint,
 957              Zminmax, Colminmax, ColOut, WithMesh, flagNax, 4L, bsiz);
 958 }
 959 /*------------------------------------------------------------------------*/
 960 static void updateXYDataBounds(int iSubwinUID, double rect[6])
 961 {
 962     int firstPlot = 0;
 963     int * piFirstPlot = &firstPlot;
 964
 965     getGraphicObjectProperty(iSubwinUID, __GO_FIRST_PLOT__, jni_bool, (void **)&piFirstPlot);
 966     if (firstPlot)
 967     {
 968         rect[4] = 0;
 969         rect[5] = 0;
 970     }
 971     else
 972     {
 973         double * dataBounds = NULL;
 974         getGraphicObjectProperty(iSubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
 975
 976         rect[0] = Min(rect[0], dataBounds[0]);
 977         rect[1] = Max(rect[1], dataBounds[1]);
 978         rect[2] = Min(rect[2], dataBounds[2]);
 979         rect[3] = Max(rect[3], dataBounds[3]);
 980         rect[4] = dataBounds[4];
 981         rect[5] = dataBounds[5];
 982     }
 983
 984     setGraphicObjectProperty(iSubwinUID, __GO_DATA_BOUNDS__, rect, jni_double_vector, 6);
 985 }
 986 /*------------------------------------------------------------------------*/
 987 static void updateXYZDataBounds(int iSubwinUID, double rect[6])
 988 {
 989     int firstPlot = 0;
 990     int * piFirstPlot = &firstPlot;
 991
 992     getGraphicObjectProperty(iSubwinUID, __GO_FIRST_PLOT__, jni_bool, (void **)&piFirstPlot);
 993     if (!firstPlot)
 994     {
 995         double * dataBounds = NULL;
 996         getGraphicObjectProperty(iSubwinUID, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
 997
 998         rect[0] = Min(rect[0], dataBounds[0]);
 999         rect[1] = Max(rect[1], dataBounds[1]);
1000         rect[2] = Min(rect[2], dataBounds[2]);
1001         rect[3] = Max(rect[3], dataBounds[3]);
1002         rect[4] = Min(rect[4], dataBounds[4]);
1003         rect[5] = Max(rect[5], dataBounds[5]);
1004     }
1005
1006     setGraphicObjectProperty(iSubwinUID, __GO_DATA_BOUNDS__, rect, jni_double_vector, 6);
1007 }
1008 /*------------------------------------------------------------------------*/