Bug 13402 fixed: Bounding boxes of xarcs were not correct
[scilab.git] / scilab / modules / graphics / src / c / sciCall.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2002-2004 - INRIA - Djalel Abdemouche
4  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
5  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
6  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2.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 != 0)
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 /*------------------------------------------------------------------------*/