Remove xor (Space Sheriff Gavan) graphic object attribute.
[scilab.git] / scilab / modules / graphics / src / c / SetProperty.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2001 - 2002 - INRIA - Mathieu Philipe
4  * Copyright (C) 2002 - 2004 - INRIA - Djalel Abdemouche
5  * Copyright (C) 2004 - 2006 - INRIA - Fabrice Leray
6  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
7  * Copyright (C) 2008 - INRIA - Vincent COUVERT
8  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
9  * Copyright (C) 2010 - Paul Griffiths
10  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
11  *
12  * This file must be used under the terms of the CeCILL.
13  * This source file is licensed as described in the file COPYING, which
14  * you should have received as part of this distribution.  The terms
15  * are also available at
16  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
17  *
18  */
19
20 /*------------------------------------------------------------------------
21  *    Graphic library
22  *    newGraph Library header
23  *    Comment:
24  *    -This file contains all functions used to SET the properties of graphics
25  *    objects.
26  *    - there are two kinds of functions : the sciInit*** which only set an object
27  *      property and sciSet*** which do the same work but check before if it is
28  *      necessary to do so.
29  *    - The returning status of each functions is as follow :
30  *      0 for correct execution, 1 if no change was made
31  *      and -1 if an error occured.
32  --------------------------------------------------------------------------*/
33
34
35 #include <stdio.h>
36 #include <string.h>
37
38 #ifdef _MSC_VER
39 #include "strdup_Windows.h"
40 #endif
41
42 #include "SetProperty.h"
43 #include "GetProperty.h"
44 #include "GetJavaProperty.h"
45 #include "InitObjects.h"
46 #include "BuildObjects.h"
47 #include "math_graphics.h"
48 #include "Scierror.h"
49 #include "CurrentFigure.h"
50 #include "ObjectSelection.h"
51 #include "BasicAlgos.h"
52 #include "FigureList.h"
53 #include "localization.h"
54 #include "SetJavaProperty.h"
55 #include "GraphicSynchronizerInterface.h"
56 #include "HandleManagement.h"
57 #include "loadTextRenderingAPI.h"
58 #include "sciprint.h"
59
60 #include "MALLOC.h"
61 #include "DrawingBridge.h"
62
63 #include "CallFigure.h"
64
65 #include "getGraphicObjectProperty.h"
66 #include "setGraphicObjectProperty.h"
67 #include "graphicObjectProperties.h"
68 #include "FigureModel.h"
69 #include "AxesModel.h"
70
71 #define MAX_MARK_STYLE 14
72
73 /*---------------------------------------------------------------------------*/
74 /* setSubWinAngles                                                                    */
75 /* Modify the viewing angles of a subwindow                                           */
76 /* for safer modifications prefer use Obj_RedrawNewAngle                              */
77 /*---------------------------------------------------------------------------*/
78 int setSubWinAngles( char *psubwin, double theta, double alpha )
79 {
80     // FIXME
81     abort();
82 #if 0
83     /**dj20003***/
84     sciSubWindow * ppSubWin = pSUBWIN_FEATURE (psubwin) ;
85
86     ppSubWin->alpha = alpha ;
87     ppSubWin->theta = theta ;
88
89     if ((alpha == 0.0) && (theta == 270.0))
90     {
91         ppSubWin->is3d = FALSE ;
92         ppSubWin->project[2]= 0; /* no z to display */
93         return 0;
94     }
95
96     ppSubWin->is3d  = TRUE  ;
97     if ((alpha == 0.0 ) || (alpha == 180.0 ) || (alpha == -180.0 ))  /* DJ.A 30/12 */
98     {
99         ppSubWin->project[2]= 0; /* no z to display */
100     }
101     else
102     {
103         ppSubWin->project[2]= 1; /* z must be displayed */
104         if (    ((alpha == 90.0 ) || (alpha == 270.0 ) || (alpha == -90.0 ) || (alpha == -270.0 ))
105                 && ((theta == 90.0 ) || (theta == -90.0 ) || (theta == 270.0 ) || (theta == -270.0 )))
106         {
107             ppSubWin->project[1]= 0; /* no y to display */
108         }
109         else
110         {
111             ppSubWin->project[1]= 1;
112             if (   ( (alpha == 90.0 ) || (alpha == 270.0 ) || (alpha == -90.0  ) || (alpha == -270.0 ))
113                    && ( (theta == 0.0  ) || (theta == 180.0 ) || (alpha == -180.0 ) ))
114             {
115                 ppSubWin->project[0]= 0; /* BUG evreywhere when theta == 0 */
116             }
117             else
118             {
119                 ppSubWin->project[0]= 1;
120             }
121         }
122     }
123 #endif
124     return 0 ;
125 }
126
127 /*---------------------------------------------------------------------------*/
128 /* Obj_RedrawNewAngle                                                                 */
129 /* Modify the viewing angles of a subwindow and the one of its brothers id necessary  */
130 /*---------------------------------------------------------------------------*/
131
132 void Obj_RedrawNewAngle(char * pSubwin, double alpha, double theta)
133 {
134 // FIXME
135     abort();
136 #if 0
137     /* check if all the axis must be turned */
138     sciPointObj * pParentFigure = sciGetParentFigure( pSubwin ) ;
139     if ( pFIGURE_FEATURE(pParentFigure)->rotstyle == 1 )
140     {
141         /* every axes has the same angles */
142         sciSons * subWins = sciGetSons( pParentFigure ) ;
143
144         /* modify each axis */
145         while ( subWins != NULL )
146         {
147             sciPointObj * curSubWin = subWins->pointobj ;
148             if ( curSubWin->entitytype == SCI_SUBWIN )
149             {
150                 setSubWinAngles( curSubWin, theta, alpha ) ;
151                 forceRedraw(curSubWin);
152             }
153             subWins = subWins->pnext ;
154         }
155     }
156     else
157     {
158         /* modify angles only for this axes */
159         setSubWinAngles( pSubwin, theta, alpha ) ;
160         forceRedraw(pSubwin);
161     }
162 #endif
163 }
164
165
166
167
168
169 /**sciSetEntityType
170  * Sets the type of this Scilab graphic object (pobjUID)
171  */
172 int
173 sciSetEntityType (char * pobjUID, sciEntityType value)
174 {
175 // FIXME
176     abort();
177 #if 0
178     if (pobj != (sciPointObj *) NULL)
179     {
180         pobj->entitytype = value ;
181         return 0 ;
182     }
183     else
184     {
185         return -1 ;
186     }
187 #endif
188     return -1;
189 }
190
191
192
193 /**sciSetColormap
194  * This function sets a colormap to the figure. It's the same for all sons.
195  * Setting the colormap a must be a m x 3 double RGB matrix:
196  * a[i] = RED, a[i+m] = GREEN, a[i+2*m] = BLUE
197  */
198 int
199 sciSetColormap ( char * pobjUID, double *rgbmat, int m, int n )
200 {
201     // FIXME
202     abort();
203 #if 0
204     int oldNbColors = sciGetNumColors(pobjUID) ;
205
206     if ( n != 3 )
207     {
208         Scierror(999, _("%s: Number of columns must be %d.\n"),"colormap",3);
209         return -1 ;
210     }
211
212     if ( SCI_FIGURE != sciGetEntityType(pobjUID) )
213     {
214         Scierror(999, _("%s: Object must be a %s.\n"),"sciSetColormap","SCI_FIGURE");
215         return -1 ;
216     }
217
218
219     pFIGURE_FEATURE(pobjUID)->numcolors = m ;
220
221     if ( pobjUID == getFigureModel() )
222     {
223         /* colormap is stored in the object */
224         FREE(pFIGURE_FEATURE(pobjUID)->pModelData->colorMap) ;
225         pFIGURE_FEATURE(pobjUID)->pModelData->colorMap = createDoubleArrayCopy(rgbmat, m * n ) ;
226         pFIGURE_FEATURE(pobjUID)->pModelData->numColors = m * n ;
227     }
228     else
229     {
230         sciSetJavaColormap( pobjUID, rgbmat, m * n ) ;
231         sciRecursiveUpdateBaW( pobjUID, oldNbColors, m ) ; /* missing line F.Leray */
232     }
233 #endif
234     return 0;
235 }
236
237
238 void sciRecursiveUpdateBaW(char *pobjUID, int old_m, int m)
239 {
240     // FIXME
241     abort();
242 #if 0
243     sciSons *psonstmp;
244
245     sciSetNumColors (pobjUID,old_m);
246
247
248     if((sciGetEntityType(pobjUID) != SCI_AXES)        &&
249        !sciIsAutomaticallyRedrawn(pobjUID))
250     {
251         if(old_m +1 == sciGetForeground(pobjUID)) {   /* 0 => deals with Foreground */
252             sciSetNumColors (pobjUID,m);
253             sciUpdateBaW (pobjUID,0,-1); /* Black */
254             sciSetNumColors (pobjUID,old_m);
255         }
256         else  if(old_m +2 == sciGetForeground(pobjUID)) {
257             sciSetNumColors (pobjUID,m);
258             sciUpdateBaW (pobjUID,0,-2); /* White */
259             sciSetNumColors (pobjUID,old_m);
260         }
261         if(old_m +1 == sciGetBackground(pobjUID)) { /* 1 => deals with Background */
262             sciSetNumColors (pobjUID,m);
263             sciUpdateBaW (pobjUID,1,-1);
264             sciSetNumColors (pobjUID,old_m);
265         }
266         else if(old_m +2 == sciGetBackground(pobjUID)) {
267             sciSetNumColors (pobjUID,m);
268             sciUpdateBaW (pobjUID,1,-2);
269             sciSetNumColors (pobjUID,old_m);
270         }
271     }
272
273     if((sciGetEntityType(pobjUID) == SCI_TEXT)        ||
274        (sciGetEntityType(pobjUID) == SCI_SUBWIN)      ||
275        (sciGetEntityType(pobjUID) == SCI_LEGEND)      ||
276        (sciGetEntityType(pobjUID) == SCI_AXES)        ||
277        (sciGetEntityType(pobjUID) == SCI_FIGURE)      ||
278        (sciGetEntityType(pobjUID) == SCI_LABEL))
279     {
280         if(old_m +1 == sciGetFontForeground(pobjUID)) {
281             /* 2 => deals with FontForeground */
282             sciSetNumColors (pobjUID,m);
283             sciUpdateBaW (pobjUID,2,-1);
284             sciSetNumColors (pobjUID,old_m);
285         }
286         else  if(old_m +2 == sciGetFontForeground(pobjUID)) {
287             sciSetNumColors (pobjUID,m);
288             sciUpdateBaW (pobjUID,2,-2);
289             sciSetNumColors (pobjUID,old_m);
290         }
291
292         if(old_m +1 == sciGetFontBackground(pobjUID)) { /* 3 => deals with FontBackground */
293             sciSetNumColors (pobjUID,m);
294             sciUpdateBaW (pobjUID,3,-1);
295             sciSetNumColors (pobjUID,old_m);
296         }
297         else if(old_m +2 == sciGetFontBackground(pobjUID)) {
298             sciSetNumColors (pobjUID,m);
299             sciUpdateBaW (pobjUID,3,-2);
300             sciSetNumColors (pobjUID,old_m);
301         }
302     }
303
304
305     /* objects that can have marks */
306     if((sciGetEntityType(pobjUID) == SCI_FIGURE)    ||
307        (sciGetEntityType(pobjUID) == SCI_SUBWIN)    ||
308        (sciGetEntityType(pobjUID) == SCI_LEGEND)    ||
309        (sciGetEntityType(pobjUID) == SCI_ARC)       ||
310        (sciGetEntityType(pobjUID) == SCI_POLYLINE)  ||
311        (sciGetEntityType(pobjUID) == SCI_RECTANGLE) ||
312        (sciGetEntityType(pobjUID) == SCI_SURFACE)   ||
313        (sciGetEntityType(pobjUID) == SCI_AXES)      ||
314        (sciGetEntityType(pobjUID) == SCI_SEGS))
315     {
316         if(old_m +1 == sciGetMarkForeground(pobjUID)) {   /* 4 => deals with MarkForeground */
317             sciSetNumColors (pobjUID,m);
318             sciUpdateBaW (pobjUID,4,-1); /* Black */
319             sciSetNumColors (pobjUID,old_m);
320         }
321         else  if(old_m +2 == sciGetMarkForeground(pobjUID)) {
322             sciSetNumColors (pobjUID,m);
323             sciUpdateBaW (pobjUID,4,-2); /* White */
324             sciSetNumColors (pobjUID,old_m);
325         }
326         if(old_m +1 == sciGetMarkBackground(pobjUID)) { /* 5 => deals with MarkBackground */
327             sciSetNumColors (pobjUID,m);
328             sciUpdateBaW (pobjUID,5,-1);
329             sciSetNumColors (pobjUID,old_m);
330         }
331         else if(old_m +2 == sciGetMarkBackground(pobjUID)) {
332             sciSetNumColors (pobjUID,m);
333             sciUpdateBaW (pobjUID,5,-2);
334             sciSetNumColors (pobjUID,old_m);
335         }
336     }
337
338     sciSetNumColors (pobjUID,m); /* Add F.Leray 25.06.04 */
339
340     // ???
341     /* psonstmp = sciGetLastSons (pobjUID); */
342     /* while (psonstmp != (sciSons *) NULL) */
343     /*   { */
344     /*     sciRecursiveUpdateBaW(psonstmp->pointobj, old_m, m); */
345     /*     psonstmp = psonstmp->pprev; */
346     /*   } */
347 #endif
348 }
349
350
351 int
352 sciUpdateBaW (char * pobjUID, int flag, int value)
353 {
354     switch (flag)
355     {
356     case 0: /* Foreground*/
357         switch (sciGetEntityType (pobjUID))
358         {
359         case SCI_POLYLINE:
360         case SCI_FIGURE:
361         case SCI_SUBWIN:
362         case SCI_ARC:
363         case SCI_SEGS:
364         case SCI_FEC:
365         case SCI_GRAYPLOT:
366         case SCI_RECTANGLE:
367         case SCI_SURFACE:
368         case SCI_AXES:
369         case SCI_LABEL: /* F.Leray 28.05.04 */
370         case SCI_TEXT:
371         case SCI_LEGEND:
372             sciSetForeground(pobjUID,value);
373             break;
374         case SCI_UIMENU:
375         case SCI_AGREG:
376         default:
377             return -1;
378             break;
379         }
380         break;
381     case 1: /* Background*/
382         switch (sciGetEntityType (pobjUID))
383         {
384         case SCI_FIGURE:
385         case SCI_SUBWIN:
386         case SCI_ARC:
387         case SCI_SEGS:
388         case SCI_FEC:
389         case SCI_GRAYPLOT:
390         case SCI_POLYLINE:
391         case SCI_RECTANGLE:
392         case SCI_SURFACE:
393         case SCI_AXES:
394         case SCI_LABEL: /* F.Leray 28.05.04 */
395         case SCI_TEXT:
396         case SCI_LEGEND:
397             sciSetBackground(pobjUID,value);
398             break;
399         case SCI_UIMENU:
400         case SCI_AGREG:
401         default:
402             return -1;
403             break;
404         }
405         break;
406     case 2: /* FontForeground*/
407         switch (sciGetEntityType (pobjUID))
408         {
409         case SCI_AXES:
410         case SCI_TEXT:
411         case SCI_LEGEND:
412         case SCI_FIGURE:
413         case SCI_SUBWIN:
414         case SCI_LABEL: /* F.Leray 28.05.04 */
415             sciSetFontForeground(pobjUID,value);
416             break;
417         default:
418             return -1;
419             break;
420         }
421         break;
422     case 3:
423         switch (sciGetEntityType (pobjUID))
424         {
425         case SCI_AXES:
426         case SCI_TEXT:
427         case SCI_LEGEND:
428         case SCI_FIGURE:
429         case SCI_SUBWIN:
430         case SCI_LABEL: /* F.Leray 28.05.04 */
431             sciSetFontBackground(pobjUID,value);
432             break;
433         case SCI_UIMENU:
434         default:
435             return -1;
436             break;
437         }
438         break;
439     case 4: /* MarkForeground*/
440         switch (sciGetEntityType (pobjUID))
441         {
442         case SCI_FIGURE:
443         case SCI_SUBWIN:
444         case SCI_LEGEND:
445         case SCI_ARC:
446         case SCI_POLYLINE:
447         case SCI_RECTANGLE:
448         case SCI_SURFACE:
449         case SCI_AXES:
450         case SCI_SEGS:
451             sciSetMarkForeground(pobjUID,value); /* F.Leray 21.01.05 */
452             break;
453         case SCI_UIMENU:
454         default:
455             return -1;
456             break;
457         }
458         break;
459     case 5: /* MarkBackground*/
460         switch (sciGetEntityType (pobjUID))
461         {
462         case SCI_FIGURE:
463         case SCI_SUBWIN:
464         case SCI_LEGEND:
465         case SCI_ARC:
466         case SCI_POLYLINE:
467         case SCI_RECTANGLE:
468         case SCI_SURFACE:
469         case SCI_AXES:
470         case SCI_SEGS:
471             sciSetMarkBackground(pobjUID,value); /* F.Leray 21.01.05 */
472             break;
473         case SCI_UIMENU:
474         default:
475             return -1;
476             break;
477         }
478         break;
479
480     default:
481         return -1;
482         break;
483     }
484
485     return 0;
486 }
487
488 int sciInitNumColors( char * pobjUID, int numcolors)
489 {
490     // FIXME
491     abort();
492 #if 0
493     /* modified jb Silvy 06/2006 */
494         if (sciGetEntityType (pobjUID)==SCI_FIGURE)
495     {
496         pFIGURE_FEATURE(pobjUID)->numcolors = numcolors ;
497         return 0 ;
498     }else{
499         return sciSetNumColors( sciGetParentFigure( pobjUID ), numcolors ) ;
500     }
501 #endif
502     return 0;
503 }
504
505 /**sciSetNumColors
506  * This function sets the number of the color defined in colormap
507  * param char * pobjUID: the pointer to the entity
508  * param int numcolor: the number of the indexed color
509  * return 0 if ok, -1 if not
510  */
511 int
512 sciSetNumColors (char * pobjUID, int numcolors)
513 {
514     if ( sciGetNumColors( pobjUID ) == numcolors )
515     {
516         /* nothing to do */
517         return 1 ;
518     }
519     return sciInitNumColors( pobjUID, numcolors ) ;
520
521 }
522
523
524 /*** Adding F.Leray 31.03.04 for supporting -1 and -2 indexes.*/
525 /* retrieve the realindex inside the colormap from the handle color property */
526 /* -1 is actually m+1 and -2, m+2 */
527 int sciSetGoodIndex(char * pobjUID, int colorindex) /* return colorindex or m (Default Black) or m+1 (Default White)*/
528 {
529     int m = sciGetNumColors (pobjUID);  /* the number of the color*/
530
531     if( colorindex == -1 ) /* Black */
532         return m + 1 ; /* modif. ici*/
533     else if( colorindex == -2 ) /* White */
534         return m + 2 ; /* modif. ici*/
535     else
536         return colorindex;
537 }
538
539 int sciInitBackground( char * pobjUID, int colorindex )
540 {
541     int m = sciGetNumColors(pobjUID);
542     if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
543
544     colorindex = sciSetGoodIndex(pobjUID,colorindex);
545
546     if (sciGetGraphicContext(pobjUID) != NULL)
547     {
548         int newIndex = Max (0, Min (colorindex - 1, m + 1));
549         sciGetGraphicContext(pobjUID)->backgroundcolor = newIndex;
550
551         if (sciGetEntityType(pobjUID) == SCI_FIGURE && !isFigureModel(pobjUID))
552         {
553                         /* disable protection since this function will call Java */
554             disableFigureSynchronization(pobjUID);
555             sciSetJavaBackground(pobjUID, newIndex);
556                         enableFigureSynchronization(pobjUID);
557         }
558
559         return 0;
560     }
561
562     /*printSetGetErrorMessage("background");*/ /* rewrite updatebaw to renable this message */
563     return -1;
564 }
565
566 /**sciSetBackground
567  * Sets the number of the Background
568  */
569 int
570 sciSetBackground (char * pobjUID, int colorindex)
571 {
572     if ( sciGetBackground( pobjUID ) == colorindex )
573     {
574         /* nothing to do */
575         return 1 ;
576     }
577
578     return sciInitBackground( pobjUID, colorindex ) ;
579
580 }
581
582
583 int sciInitForeground( char * pobjUID, int colorindex )
584 {
585     // FIXME
586     abort();
587 #if 0
588     int m = sciGetNumColors(pobjUID);
589     if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
590
591     colorindex = sciSetGoodIndex(pobjUID,colorindex);
592
593     if (sciGetGraphicContext(pobjUID) != NULL)
594     {
595         sciGetGraphicContext(pobjUID)->foregroundcolor = Max (0, Min (colorindex - 1, m + 1));
596         return 0;
597     }
598
599     /*printSetGetErrorMessage("foreground");*/ /* rewrite updatebaw to renable this message */
600 #endif
601     return -1;
602 }
603
604 /**sciSetForeground
605  * sets the number of the Foreground
606  */
607 int
608 sciSetForeground (char * pobjUID, int colorindex)
609 {
610     if ( sciGetForeground( pobjUID ) == colorindex )
611     {
612         return 1 ;
613     }
614     return sciInitForeground( pobjUID, colorindex ) ;
615
616 }
617
618 int sciSetLineWidth( char * pobjUID, double linewidth )
619 {
620 /*
621  * Deactivated: the property is set within the MVC regardless of its
622  * currently stored value.
623  */
624 #if 0
625     if ( sciGetLineWidth( pobjUID ) == linewidth )
626     {
627         /* nothing to do */
628         return 1 ;
629     }
630 #endif
631
632     return sciInitLineWidth( pobjUID, linewidth ) ;
633 }
634
635
636 /**sciSetLineWidth
637  * Sets the line width
638  */
639 int
640 sciInitLineWidth (char * pobjUID, double linewidth)
641 {
642     BOOL status;
643
644     if (linewidth < 0)
645     {
646         Scierror(999, _("Line width must be greater than %d.\n"),0);
647         return -1;
648     }
649     else
650     {
651         status = setGraphicObjectProperty(pobjUID, __GO_LINE_THICKNESS__, &linewidth, jni_double, 1);
652
653         if (status == TRUE)
654         {
655             return 0;
656         }
657     }
658     printSetGetErrorMessage("thickness");
659     return -1;
660 }
661
662
663 int sciSetLineStyle( char * pobjUID, int linestyle )
664 {
665 /*
666  * Deactivated: the property is set within the MVC regardless of its
667  * currently stored value.
668  */
669 #if 0
670     if ( sciGetLineStyle( pobjUID ) == linestyle )
671     {
672         /* nothing to do */
673         return 1 ;
674     }
675 #endif
676
677     return sciInitLineStyle( pobjUID, linestyle ) ;
678 }
679
680 /**sciSetLineStyle
681  * Sets the line style
682  */
683 int
684 sciInitLineStyle (char * pobjUID, int linestyle)
685 {
686     BOOL status;
687     if (linestyle < 0)
688     {
689         Scierror(999, _("The line style must be greater than %d.\n"),0);
690         return -1;
691     }
692     else
693     {
694         status = setGraphicObjectProperty(pobjUID, __GO_LINE_STYLE__, &linestyle, jni_int, 1);
695
696         if (status == TRUE)
697         {
698             return 0;
699         }
700     }
701
702     printSetGetErrorMessage("line_style");
703     return -1;
704 }
705
706
707 int sciInitIsMark( char * pobjUID, BOOL ismark )
708 {
709
710     if (sciGetGraphicContext(pobjUID) != NULL)
711     {
712         sciGetGraphicContext(pobjUID)->ismark = ismark;
713         return 0;
714     }
715
716     printSetGetErrorMessage("mark_mode");
717     return -1;
718
719 }
720
721 /**sciSetIsMark
722  * Sets the line style
723  */
724 int
725 sciSetIsMark (char * pobjUID, BOOL ismark)
726 {
727
728     if ( sciGetIsMark(pobjUID) == ismark )
729     {
730         /* nothing to do */
731         return 1 ;
732     }
733     return sciInitIsMark( pobjUID, ismark ) ;
734
735 }
736
737
738 int sciInitMarkForeground( char * pobjUID, int colorindex )
739 {
740     if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
741     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
742
743     if (sciGetGraphicContext(pobjUID) != NULL)
744     {
745         sciGetGraphicContext(pobjUID)->markforeground =
746             Max (-1, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
747         return 0;
748     }
749
750     printSetGetErrorMessage("mark_foreground");
751     return -1;
752
753 }
754
755 /**sciSetMarkForeground
756  * sets the number of the Marks'Foreground
757  */
758 int
759 sciSetMarkForeground (char * pobjUID, int colorindex)
760 {
761
762     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
763     if ( sciGetMarkForeground( pobjUID ) == colorindex )
764     {
765         /* nothing to do */
766         return 1 ;
767     }
768     return sciInitMarkForeground( pobjUID, colorindex ) ;
769
770 }
771
772 int sciInitMarkBackground( char * pobjUID, int colorindex )
773 {
774     if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
775     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
776
777     if (sciGetGraphicContext(pobjUID) != NULL)
778     {
779         sciGetGraphicContext(pobjUID)->markbackground =
780             Max (-1, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
781         return 0;
782     }
783
784     printSetGetErrorMessage("mark_background");
785     return -1;
786 }
787
788 /**sciSetMarkBackground
789  * sets the number of the Marks'Background
790  */
791 int
792 sciSetMarkBackground (char * pobjUID, int colorindex)
793 {
794
795     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
796
797     if ( sciGetMarkBackground( pobjUID ) == colorindex )
798     {
799         /* nothing to do */
800         return 1 ;
801     }
802     return sciInitMarkBackground( pobjUID, colorindex ) ;
803
804 }
805
806
807
808 int sciInitMarkStyle( char * pobjUID, int markstyle )
809 {
810     BOOL status;
811
812     if (markstyle < 0 || markstyle > MAX_MARK_STYLE )
813     {
814         Scierror(999, _("Wrong value for '%s' property: Must be between %d and %d.\n"), "mark_style", 0, MAX_MARK_STYLE);
815         return -1;
816     }
817     else
818     {
819         status = setGraphicObjectProperty(pobjUID, __GO_MARK_STYLE__, &markstyle, jni_int, 1);
820
821         if (status == TRUE)
822         {
823             return 0;
824         }
825     }
826
827     printSetGetErrorMessage("mark_style");
828     return -1;
829 }
830
831
832 /**sciSetMarkStyle
833  * Sets the mark style
834  */
835 int
836 sciSetMarkStyle (char * pobjUID, int markstyle)
837 {
838 /*
839  * Deactivated: the property is set within the MVC regardless of its
840  * currently stored value.
841  */
842 #if 0
843     if ( sciGetMarkStyle( pobjUID ) == markstyle )
844     {
845         /* nothing to do */
846         return 1 ;
847     }
848 #endif
849
850     return sciInitMarkStyle( pobjUID, markstyle ) ;
851 }
852
853 int sciInitMarkSize( char * pobjUID, int marksize )
854 {
855     if (marksize < 0)
856     {
857         Scierror(999, _("The mark size must be greater or equal than %d.\n"),0);
858         return -1;
859     }
860     else
861     {
862         BOOL status;
863
864         status = setGraphicObjectProperty(pobjUID, __GO_MARK_SIZE__, &marksize, jni_int, 1);
865
866         if (status == TRUE)
867         {
868             return 0;
869         }
870     }
871
872     printSetGetErrorMessage("mark_size");
873     return -1;
874 }
875
876 /**sciSetMarkSize
877  * Sets the mark size
878  */
879 int
880 sciSetMarkSize (char * pobjUID, int marksize)
881 {
882 /*
883  * Deactivated: the property is set within the MVC regardless of its
884  * currently stored value.
885  */
886 #if 0
887     if ( sciGetMarkSize( pobjUID ) == marksize )
888     {
889         /* nothing to do */
890         return 1 ;
891     }
892 #endif
893
894     return sciInitMarkSize( pobjUID, marksize ) ;
895 }
896
897 int sciInitMarkSizeUnit( char * pobjUID, int marksizeunit )
898 {
899     if (marksizeunit < 0)
900     {
901         Scierror(999, _("The mark size unit must be greater than %d.\n"),0);
902         return -1;
903     }
904     else
905     {
906         if (sciGetGraphicContext(pobjUID) != NULL)
907         {
908             (sciGetGraphicContext(pobjUID))->marksizeunit = marksizeunit;
909             return 0;
910         }
911     }
912
913     printSetGetErrorMessage("mark_size_unit");
914     return -1;
915 }
916
917 /**sciSetMarkSizeUnit
918  * Sets the mark size unit
919  * 1 : points, 2 : tabulated
920  */
921 int
922 sciSetMarkSizeUnit (char * pobjUID, int marksizeunit)
923 {
924 /*
925  * Deactivated: the property is set within the MVC regardless of its
926  * currently stored value.
927  */
928 #if 0
929     if ( sciGetMarkSizeUnit( pobjUID ) == marksizeunit )
930     {
931         /* nothing to do */
932         return 1 ;
933     }
934 #endif
935
936     return sciInitMarkSizeUnit( pobjUID, marksizeunit ) ;
937 }
938
939 int sciInitIsLine( char * pobjUID, BOOL isline )
940 {
941
942     if (sciGetGraphicContext(pobjUID) != NULL)
943     {
944         sciGetGraphicContext(pobjUID)->isline = isline;
945         return 0;
946     }
947
948     printSetGetErrorMessage("line_mode");
949     return -1;
950
951 }
952
953 /**sciSetIsLine
954  * Sets the line style existence
955  */
956 int
957 sciSetIsLine (char * pobjUID, BOOL isline)
958 {
959
960     if ( sciGetIsLine( pobjUID ) == isline )
961     {
962         /* nothing to do */
963         return 1 ;
964     }
965     return sciInitIsLine( pobjUID, isline ) ;
966 }
967 /**sciInitPolylineStyle
968  * Sets Polyline Style (plot)
969  */
970 int sciInitPolylineStyle( char * pobjUID, int plot )
971 {
972     // FIXME
973     abort();
974 #if 0
975     if (sciGetEntityType(pobjUID) == SCI_POLYLINE)
976     {
977         pPOLYLINE_FEATURE(pobjUID)->plot = 4;
978         return 0;
979     }
980
981     printSetGetErrorMessage("polyline_style");
982 #endif
983     return -1;
984
985 }
986 /**sciInitArrowSize
987  * Sets Polyline arrow size (to be used with polyline_style=4)
988  */
989 int sciInitArrowSize( char * pobjUID, double size )
990 {
991     // FIXME
992     abort();
993 #if 0
994     if (sciGetEntityType(pobjUID) == SCI_POLYLINE)
995     {
996         pPOLYLINE_FEATURE(pobjUID)->arsize_factor = size;
997         return 0;
998     }
999
1000     printSetGetErrorMessage("arrow_size");
1001 #endif
1002     return -1;
1003
1004 }
1005
1006
1007 int sciInitFontSize( char * pobjUID, double fontSize )
1008 {
1009     if (fontSize < 0)
1010     {
1011         Scierror(999, _("The font size must be greater than %d.\n"),0);
1012         return -1;
1013     }
1014     else
1015     {
1016         if (sciGetFontContext(pobjUID) != NULL)
1017         {
1018             (sciGetFontContext(pobjUID))->fontSize = fontSize;
1019             return 0;
1020         }
1021         else
1022         {
1023             printSetGetErrorMessage("font_size");
1024             return -1;
1025         }
1026     }
1027 }
1028
1029 /**sciSetFontSize
1030  * Sets the font size
1031  */
1032 int sciSetFontSize(char * pobjUID, double fontSize)
1033 {
1034
1035     if (sciGetFontSize( pobjUID ) == fontSize)
1036     {
1037         /* nothing to do */
1038         return 1 ;
1039     }
1040     return sciInitFontSize(pobjUID, fontSize) ;
1041
1042 }
1043
1044 int sciInitFontOrientation( char * pobjUID, double textorientation )
1045 {
1046     if (sciGetFontContext(pobjUID) != NULL)
1047     {
1048         (sciGetFontContext(pobjUID))->textorientation = textorientation;
1049         return 0;
1050     }
1051     printSetGetErrorMessage("font_angle");
1052     return -1;
1053 }
1054
1055
1056
1057 /**sciSetFontOrientation
1058  * Sets the font Orientation
1059  */
1060 int
1061 sciSetFontOrientation (char * pobjUID, double textorientation)
1062 {
1063
1064     if ( sciGetFontOrientation( pobjUID ) == textorientation )
1065     {
1066         /* nothing to do */
1067         return 1 ;
1068     }
1069     return sciInitFontOrientation( pobjUID, textorientation ) ;
1070
1071 }
1072
1073 int sciSetStrings( char * pobjUIDDest, const StringMatrix * pStrings )
1074 {
1075     // FIXME
1076     abort();
1077 #if 0
1078     switch (sciGetEntityType (pobjUIDDest))
1079     {
1080     case SCI_TEXT:
1081         deleteMatrix( pTEXT_FEATURE (pobjUIDDest)->pStrings ) ;
1082         pTEXT_FEATURE (pobjUIDDest)->pStrings = copyStringMatrix( pStrings ) ;
1083         if ( pTEXT_FEATURE (pobjUIDDest)->pStrings == NULL )
1084         {
1085             return -1 ;
1086         }
1087         break;
1088     case SCI_LEGEND:
1089         deleteMatrix( pLEGEND_FEATURE (pobjUIDDest)->text.pStrings ) ;
1090         pLEGEND_FEATURE (pobjUIDDest)->text.pStrings = copyStringMatrix( pStrings ) ;
1091         if ( pLEGEND_FEATURE (pobjUIDDest)->text.pStrings == NULL )
1092         {
1093             return -1 ;
1094         }
1095         break;
1096     case SCI_LABEL: /* F.Leray 28.05.04 */
1097         return sciSetStrings( pLABEL_FEATURE(pobjUIDDest)->text, pStrings ) ;
1098         break;
1099     case SCI_UIMENU:
1100     case SCI_FIGURE:
1101     case SCI_SUBWIN:
1102     case SCI_ARC:
1103     case SCI_SEGS:
1104     case SCI_FEC:
1105     case SCI_GRAYPLOT:
1106     case SCI_POLYLINE:
1107     case SCI_RECTANGLE:
1108     case SCI_SURFACE:
1109     case SCI_AXES:
1110     case SCI_AGREG:
1111     default:
1112         printSetGetErrorMessage("text");
1113         return -1;
1114         break;
1115     }
1116 #endif
1117     return 0;
1118 }
1119
1120 /**sciSetText
1121  * Sets the Text in TEXT, TITLE or LEGEND
1122  * @param char * pobjUID: the pointer to the entity
1123  * @param char *text[] : the text which has to be put
1124  * @param int nbRow : the number of row of the text matrix
1125  * @param int nbCol : the number of col of the text matrix
1126  * @return  0 if OK, -1 if not
1127  */
1128 int sciSetText (char * pobjUID, char ** text, int nbRow, int nbCol)
1129 {
1130     int dimensions[2];
1131     BOOL status;
1132
1133     /* Check if we should load LaTex / MathML Java libraries */
1134     loadTextRenderingAPI(text, nbRow, nbCol);
1135
1136     dimensions[0] = nbRow;
1137     dimensions[1] = nbCol;
1138
1139     status = setGraphicObjectProperty(pobjUID, __GO_TEXT_ARRAY_DIMENSIONS__, dimensions, jni_int_vector, 2);
1140
1141     if (status != TRUE)
1142     {
1143         printSetGetErrorMessage("text");
1144         return -1;
1145     }
1146
1147     status = setGraphicObjectProperty(pobjUID, __GO_TEXT_STRINGS__, text, jni_string_vector, dimensions[0]*dimensions[1]);
1148
1149     if (status == TRUE)
1150     {
1151         return 0;
1152     }
1153     else
1154     {
1155         printSetGetErrorMessage("text");
1156         return -1;
1157     }
1158 }
1159
1160
1161 int sciInitFontBackground( char * pobjUID, int colorindex )
1162 {
1163     // FIXME
1164     abort();
1165 #if 0
1166     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
1167     switch (sciGetEntityType (pobjUID))
1168     {
1169     case SCI_TEXT:
1170         (sciGetFontContext(pobjUID))->backgroundcolor =
1171             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1172         break;
1173     case SCI_LEGEND:
1174         (sciGetFontContext(pobjUID))->backgroundcolor =
1175             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1176         break;
1177     case SCI_AXES:
1178         (sciGetFontContext(pobjUID))->backgroundcolor =
1179             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1180         break;
1181     case SCI_SUBWIN: /* F.Leray 08.04.04 */
1182         (sciGetFontContext(pobjUID))->backgroundcolor =
1183             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1184         break;
1185     case SCI_FIGURE: /* F.Leray 08.04.04 */
1186         (sciGetFontContext(pobjUID))->backgroundcolor =
1187             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1188         break;
1189     case SCI_LABEL: /* F.Leray 28.05.04 */
1190         (sciGetFontContext(pobjUID))->backgroundcolor =
1191             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1192         break;
1193     case SCI_UIMENU:
1194     case SCI_ARC:
1195     case SCI_SEGS:
1196     case SCI_FEC:
1197     case SCI_GRAYPLOT:
1198     case SCI_POLYLINE:
1199     case SCI_RECTANGLE:
1200     case SCI_SURFACE:
1201     case SCI_AGREG:
1202     default:
1203         printSetGetErrorMessage("font_background");
1204         return -1;
1205         break;
1206     }
1207 #endif
1208     return 0;
1209 }
1210
1211 /**sciSetFontBackground
1212  * Sets the background color
1213  * @param char * pobjUID: the pointer to the entity
1214  * @return  int 0 if OK, -1 if not
1215  */
1216 int
1217 sciSetFontBackground (char * pobjUID, int colorindex)
1218 {
1219     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
1220
1221     if ( sciGetFontBackground( pobjUID ) == colorindex )
1222     {
1223         /* nothing to do */
1224         return 1 ;
1225     }
1226     return sciInitFontBackground( pobjUID, colorindex ) ;
1227
1228 }
1229
1230 int sciInitFontForeground( char * pobjUID, int colorindex )
1231 {
1232      // FIXME
1233     abort();
1234 #if 0
1235    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
1236
1237     switch (sciGetEntityType (pobjUID))
1238     {
1239     case SCI_TEXT:
1240         (sciGetFontContext(pobjUID))->foregroundcolor =
1241             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1242         break;
1243     case SCI_LEGEND:
1244         (sciGetFontContext(pobjUID))->foregroundcolor =
1245             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1246         break;
1247     case SCI_AXES:
1248         (sciGetFontContext(pobjUID))->foregroundcolor =
1249             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1250         break;
1251     case SCI_SUBWIN: /* F.Leray 08.04.04 */
1252         (sciGetFontContext(pobjUID))->foregroundcolor =
1253             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1254         break;
1255     case SCI_FIGURE: /* F.Leray 08.04.04 */
1256         (sciGetFontContext(pobjUID))->foregroundcolor =
1257             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1258         break;
1259     case SCI_LABEL: /* F.Leray 08.04.04 */
1260         (sciGetFontContext(pobjUID))->foregroundcolor =
1261             Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
1262         break;
1263     case SCI_UIMENU:
1264     case SCI_ARC:
1265     case SCI_SEGS:
1266     case SCI_FEC:
1267     case SCI_GRAYPLOT:
1268     case SCI_POLYLINE:
1269     case SCI_RECTANGLE:
1270     case SCI_SURFACE:
1271     case SCI_AGREG:
1272     default:
1273         printSetGetErrorMessage("font_foreground");
1274         return -1;
1275         break;
1276     }
1277 #endif
1278     return 0;
1279 }
1280
1281 /**sciSetFontForeground
1282  * Sets the foreground color
1283  * @param char * pobjUID: the pointer to the entity
1284  * @return  int 0 if OK, if not
1285  */
1286 int
1287 sciSetFontForeground (char * pobjUID, int colorindex)
1288 {
1289     colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
1290
1291     if ( sciGetFontForeground( pobjUID ) == colorindex )
1292     {
1293         /* nothing to do */
1294         return 1 ;
1295     }
1296
1297     return sciInitFontForeground( pobjUID, colorindex ) ;
1298 }
1299
1300
1301 int sciInitFontStyle( char * pobjUID, int iAttributes )
1302 {
1303     // FIXME
1304     abort();
1305 #if 0
1306     switch (sciGetEntityType (pobjUID))
1307     {
1308     case SCI_TEXT:
1309     case SCI_LEGEND:
1310     case SCI_SUBWIN:
1311     case SCI_FIGURE:
1312     case SCI_LABEL: /* F.Leray 10.06.04 */
1313         (sciGetFontContext(pobjUID))->fonttype =iAttributes;
1314         break;
1315     case SCI_UIMENU:
1316     case SCI_ARC:
1317     case SCI_SEGS:
1318     case SCI_FEC:
1319     case SCI_GRAYPLOT:
1320     case SCI_POLYLINE:
1321     case SCI_RECTANGLE:
1322     case SCI_SURFACE:
1323     case SCI_AXES:
1324     case SCI_AGREG:
1325     default:
1326         printSetGetErrorMessage("font_style");
1327         return -1;
1328         break;
1329     }
1330 #endif
1331     return 0;
1332 }
1333
1334 /**sciSetFontStyle
1335  * Sets the font style
1336  * @param char * pobjUID: the pointer to the entity
1337  * @param  int iAttributes (a logical mask with SCI_ATTR_BOLD|SCI_ATTR_ITALIC|SCI_ATTR_UNDERLINE|SCI_ATTR_STRIKEOUT)
1338  * @return  int 0 if OK, -1 if not
1339  */
1340 int
1341 sciSetFontStyle (char * pobjUID, int iAttributes )
1342 {
1343     if ( sciGetFontStyle( pobjUID ) == iAttributes )
1344     {
1345         /* nothing to do */
1346         return 1 ;
1347     }
1348     return sciInitFontStyle( pobjUID, iAttributes ) ;
1349
1350 }
1351
1352
1353 int sciInitLegendPlace( char * pobjUID, sciLegendPlace place )
1354 {
1355     // FIXME
1356     abort();
1357 #if 0
1358     double position[2]={0.0,0.0};
1359
1360     if (sciGetEntityType (pobjUID) == SCI_LEGEND)
1361     {
1362         pLEGEND_FEATURE (pobjUID)->place = place;
1363         /* calcul de l emplacement relatif du titre
1364          * en fonction de la taille de la police
1365          * de la fenetre...
1366          */
1367         return sciInitLegendPos (pobjUID, position );
1368     }
1369
1370     Scierror(999, _("You are not using a legend object.\n"));
1371 #endif
1372     return -1;
1373 }
1374
1375 /**sciSetLegendPlace
1376  * Sets the Title Place  with SCI_TITLE_IN_TOP or SCI_TITLE_IN_BOTTOM and calculate the real position in the window
1377  * @param char * pobjUID: the pointer to the entity
1378  * @return 0 if ok, -1 if not
1379  */
1380 int
1381 sciSetLegendPlace (char * pobjUID, sciLegendPlace place)
1382 {
1383
1384
1385     if ( sciGetLegendPlace( pobjUID ) == place )
1386     {
1387         /* nothing to do */
1388         return 1 ;
1389     }
1390     return sciInitLegendPlace( pobjUID, place ) ;
1391
1392 }
1393
1394 int sciInitLegendPos( char * pobjUID, double position[] )
1395 {
1396     // FIXME
1397     abort();
1398 #if 0
1399     switch (sciGetEntityType (pobjUID))
1400     {
1401     case SCI_LEGEND:
1402         pLEGEND_FEATURE (pobjUID)->pos.x = position[0];
1403         pLEGEND_FEATURE (pobjUID)->pos.y = position[1];
1404         break;
1405     case SCI_FIGURE:
1406     case SCI_SUBWIN:
1407     case SCI_TEXT:
1408     case SCI_ARC:
1409     case SCI_SEGS:
1410     case SCI_FEC:
1411     case SCI_GRAYPLOT:
1412     case SCI_POLYLINE:
1413     case SCI_RECTANGLE:
1414     case SCI_SURFACE:
1415     case SCI_AXES:
1416     case SCI_AGREG:
1417     case SCI_LABEL:
1418     case SCI_UIMENU:
1419     default:
1420         Scierror(999, _("You are not using a legend object.\n"));
1421         return -1;
1422         break;
1423     }
1424 #endif
1425     return 0;
1426 }
1427
1428 /**sciSetLegendPos
1429  * Sets the Legend Position in the window
1430  * @param char * pobjUID: the pointer to the entity
1431  * @return 0 if ok, -1 if not
1432  */
1433 int
1434 sciSetLegendPos (char * pobjUID, double position[])
1435 {
1436     double position_old[2] ;
1437     sciGetLegendPos( pobjUID ,position_old) ;
1438     if ( position[0] ==  position_old[0] && position[1] == position_old[1] )
1439     {
1440         /* nothing to do */
1441         return 1 ;
1442     }
1443     return sciInitLegendPos( pobjUID, position ) ;
1444 }
1445
1446 int sciInitIsClipping( char * pobjUID, int value )
1447 {
1448     // FIXME
1449     abort();
1450 #if 0
1451     switch (sciGetEntityType (pobjUID))
1452     {
1453     case SCI_SUBWIN:
1454         pSUBWIN_FEATURE (pobjUID)->isclip = value;
1455         if(value>0) pSUBWIN_FEATURE (pobjUID)->clip_region_set=1;
1456         break;
1457     case SCI_ARC:
1458         pARC_FEATURE (pobjUID)->isclip = value;
1459         if(value>0) pARC_FEATURE (pobjUID)->clip_region_set=1;
1460         break;
1461     case SCI_POLYLINE:
1462         pPOLYLINE_FEATURE (pobjUID)->isclip = value;
1463         if(value>0) pPOLYLINE_FEATURE (pobjUID)->clip_region_set=1;
1464         break;
1465     case SCI_RECTANGLE:
1466         pRECTANGLE_FEATURE (pobjUID)->isclip = value;
1467         if(value>0) pRECTANGLE_FEATURE (pobjUID)->clip_region_set=1;
1468         break;
1469     case SCI_SEGS:
1470         pSEGS_FEATURE (pobjUID)->isclip = value;
1471         if(value>0) pSEGS_FEATURE (pobjUID)->clip_region_set=1;
1472         break;
1473     case SCI_TEXT:
1474         pTEXT_FEATURE (pobjUID)->isclip = value;
1475         if(value>0) pTEXT_FEATURE (pobjUID)->clip_region_set=1;
1476         break;
1477     case SCI_AXES:
1478         pAXES_FEATURE (pobjUID)->isclip = value;
1479         if(value>0) pAXES_FEATURE (pobjUID)->clip_region_set=1;
1480         break;
1481     case SCI_SURFACE:
1482         pSURFACE_FEATURE (pobjUID)->isclip = value;
1483         if(value>0) pSURFACE_FEATURE (pobjUID)->clip_region_set=1;
1484         break;
1485     case SCI_FEC:
1486         pFEC_FEATURE (pobjUID)->isclip = value;
1487         if(value>0) pFEC_FEATURE (pobjUID)->clip_region_set=1;
1488         break;
1489     case SCI_GRAYPLOT:
1490         pGRAYPLOT_FEATURE (pobjUID)->isclip = value;
1491         if(value>0) pGRAYPLOT_FEATURE (pobjUID)->clip_region_set=1;
1492         break;
1493     case SCI_LEGEND:
1494         pLEGEND_FEATURE(pobjUID)->isclip = value;
1495         if(value>0) { pLEGEND_FEATURE (pobjUID)->clip_region_set=1;}
1496         break;
1497     case SCI_AGREG:
1498     case SCI_FIGURE:
1499     case SCI_LABEL: /* F.Leray 28.05.04 */
1500     case SCI_UIMENU:
1501     default:
1502         printSetGetErrorMessage("clip_state");
1503         return -1 ;
1504         break;
1505     }
1506 #endif
1507     return 0 ;
1508 }
1509
1510 /**sciSetIsClipping*/
1511 int
1512 sciSetIsClipping( char * pobjUID, int value )
1513 {
1514
1515     if ( sciGetIsClipping( pobjUID ) == value )
1516     {
1517         /* nothing to do */
1518         return 1 ;
1519     }
1520     return sciInitIsClipping( pobjUID, value ) ;
1521
1522 }
1523
1524
1525 /**sciSetClipping
1526  * Sets the clipping area
1527  * @author Djalel ABDEMOUCHE
1528  * 29/11/2002
1529  */
1530 int
1531 sciSetClipping (char * pobjUID, double pclip[4] )
1532 {
1533     // FIXME
1534     abort();
1535 #if 0
1536     int i;
1537
1538     switch (sciGetEntityType (pobjUID))
1539     {
1540     case SCI_SUBWIN:
1541         for(i=0;i<4;i++) {pSUBWIN_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1542         break;
1543     case SCI_ARC:
1544         for(i=0;i<4;i++) {pARC_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1545         break;
1546     case SCI_POLYLINE:
1547         for(i=0;i<4;i++) {pPOLYLINE_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1548         break;
1549     case SCI_RECTANGLE:
1550         for(i=0;i<4;i++) {pRECTANGLE_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1551         break;
1552     case SCI_SEGS:
1553         for(i=0;i<4;i++) {pSEGS_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1554         break;
1555     case SCI_TEXT:
1556         for(i=0;i<4;i++) {pTEXT_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1557         break;
1558     case SCI_AXES:
1559         for(i=0;i<4;i++) {pAXES_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1560         break;
1561     case SCI_SURFACE:
1562         for(i=0;i<4;i++) {pSURFACE_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1563         break;
1564     case SCI_LEGEND:
1565         for(i=0;i<4;i++) {pLEGEND_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1566         break;
1567     case SCI_FEC:
1568         for(i=0;i<4;i++) {pFEC_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1569         break;
1570     case SCI_GRAYPLOT:
1571         for(i=0;i<4;i++) {pGRAYPLOT_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
1572         break;
1573     case SCI_LABEL:
1574         return sciSetClipping( pLABEL_FEATURE (pobjUID)->text, pclip ) ;
1575         break;
1576     case SCI_AGREG:
1577     case SCI_FIGURE:
1578     case SCI_UIMENU:
1579     default:
1580         printSetGetErrorMessage("clip_box");
1581         return -1;
1582         break;
1583     }
1584 #endif
1585     return 0;
1586
1587 }
1588
1589
1590 int sciInitAddPlot( char * pobjUID, BOOL value )
1591 {
1592     // FIXME
1593     abort();
1594 #if 0
1595     switch (sciGetEntityType (pobjUID))
1596     {
1597     case SCI_FIGURE:
1598         (sciGetGraphicMode (pobjUID))->addplot = value;
1599         break;
1600     case SCI_SUBWIN:
1601         (sciGetGraphicMode (pobjUID))->addplot = value;
1602         /*(sciGetGraphicMode (sciGetParentFigure(pobjUID)))->addplot = value;*/
1603         break;
1604     case SCI_TEXT:
1605     case SCI_LEGEND:
1606     case SCI_ARC:
1607     case SCI_SEGS:
1608     case SCI_FEC:
1609     case SCI_GRAYPLOT:
1610     case SCI_POLYLINE:
1611     case SCI_RECTANGLE:
1612     case SCI_SURFACE:
1613     case SCI_AXES:
1614     case SCI_AGREG:
1615     case SCI_LABEL: /* F.Leray 28.05.04 */
1616     case SCI_UIMENU:
1617     default:
1618         printSetGetErrorMessage("auto_clear");
1619         return -1 ;
1620         break;
1621     }
1622 #endif
1623     return 0 ;
1624 }
1625
1626 /**sciSetAddPlot
1627  * Tunrs ON or OFF the possibility to draw multi plots in one graphic.
1628  * If FALSE, plot is cleared before new drawing
1629  */
1630 int
1631 sciSetAddPlot (char * pobjUID, BOOL value)
1632 {
1633     if ( sciGetAddPlot( pobjUID ) == value )
1634     {
1635         /* nothing to do */
1636         return 1 ;
1637     }
1638     return sciInitAddPlot( pobjUID, value ) ;
1639
1640 }
1641
1642
1643 int sciInitAutoScale( char * pobjUID, BOOL value )
1644 {
1645     // FIXME
1646     abort();
1647 #if 0
1648         switch (sciGetEntityType (pobjUID))
1649     {
1650     case SCI_FIGURE:
1651         if (pobjUID == getFigureModel())
1652             (sciGetGraphicMode (pobjUID))->autoscaling = value;
1653         else
1654             sciSetAutoScale(sciGetFirstTypedSelectedSon(pobjUID, SCI_SUBWIN),value);
1655         break;
1656     case SCI_SUBWIN:
1657         (sciGetGraphicMode (pobjUID))->autoscaling = value;
1658         break;
1659     case SCI_TEXT:
1660     case SCI_LEGEND:
1661     case SCI_ARC:
1662     case SCI_SEGS:
1663     case SCI_FEC:
1664     case SCI_GRAYPLOT:
1665     case SCI_POLYLINE:
1666     case SCI_RECTANGLE:
1667     case SCI_SURFACE:
1668     case SCI_AXES:
1669     case SCI_AGREG:
1670     case SCI_LABEL: /* F.Leray 28.05.04 */
1671     case SCI_UIMENU:
1672     default:
1673         printSetGetErrorMessage("autos_cale");
1674         return -1 ;
1675         break;
1676     }
1677 #endif
1678     return 0 ;
1679 }
1680
1681 /**sciSetAutoScale
1682  * Sets the mode if the plot is in zoom fit mode, or fixed by the user
1683  */
1684 int
1685 sciSetAutoScale (char * pobjUID, BOOL value)
1686 {
1687
1688     if ( sciGetAutoScale( pobjUID ) == value )
1689     {
1690         /* nothing to do */
1691         return 1 ;
1692     }
1693     return sciInitAutoScale( pobjUID, value ) ;
1694
1695 }
1696
1697 int sciInitZooming( char * pobjUID, BOOL value )
1698 {
1699     // FIXME
1700     abort();
1701 #if 0
1702         switch (sciGetEntityType (pobjUID))
1703     {
1704     case SCI_FIGURE:
1705         (sciGetGraphicMode (pobjUID))->zooming = value;
1706         break;
1707     case SCI_SUBWIN:
1708         (sciGetGraphicMode (pobjUID))->zooming = value;
1709         /* the value is inhirated by the parent */
1710         sciSetZooming (sciGetParentFigure (pobjUID), value);
1711         break;
1712     case SCI_TEXT:
1713     case SCI_LEGEND:
1714     case SCI_ARC:
1715     case SCI_SEGS:
1716     case SCI_FEC:
1717     case SCI_GRAYPLOT:
1718     case SCI_POLYLINE:
1719     case SCI_RECTANGLE:
1720     case SCI_SURFACE:
1721     case SCI_AXES:
1722     case SCI_AGREG:
1723     case SCI_LABEL: /* F.Leray 28.05.04 */
1724     case SCI_UIMENU:
1725     default:
1726         printSetGetErrorMessage("zoom");
1727         return -1 ;
1728         break;
1729     }
1730 #endif
1731     return 0 ;
1732 }
1733
1734 /**sciSetZooming
1735  * Sets the zooming state of the object. Is it or not zommed right now
1736  */
1737 int
1738 sciSetZooming (char * pobjUID, BOOL value)
1739 {
1740     if ( sciGetZooming( pobjUID ) == value )
1741     {
1742         /* nothing to do */
1743         return 1 ;
1744     }
1745     return sciInitZooming( pobjUID, value ) ;
1746
1747 }
1748
1749
1750 /**sciSetDefaultValue
1751  * Sets the default values of figure properties
1752  * (graphics context, graphics mode, and graphics font)
1753  * @author Djalel ABDEMOUCHE
1754  */
1755 int
1756 sciSetDefaultValues (void)
1757 {
1758 // ???
1759 #if 0
1760     if ((sciInitGraphicContext (sciGetCurrentFigure()) == -1) ||
1761         (sciInitGraphicMode (sciGetCurrentFigure()) == -1) ||
1762         (sciInitFontContext (sciGetCurrentFigure()) == -1)) /* Adding F.Leray 13.04.04 to have the completed init.*/
1763     {
1764         Scierror(999, _("Unable to load default values.\n"));
1765         return -1 ;
1766     }
1767 #endif
1768     return 0;
1769 }
1770
1771 int sciInitVisibility( char * pobjUID, BOOL value )
1772 {
1773     // FIXME
1774     abort();
1775 #if 0
1776
1777     switch (sciGetEntityType (pobjUID))
1778     {
1779     case SCI_FIGURE:
1780         pFIGURE_FEATURE (pobjUID)->visible = value;
1781         break;
1782     case SCI_SUBWIN:
1783         pSUBWIN_FEATURE (pobjUID)->visible = value;
1784         break;
1785     case SCI_LEGEND:
1786         pLEGEND_FEATURE (pobjUID)->visible = value;
1787         break;
1788     case SCI_ARC:
1789         pARC_FEATURE (pobjUID)->visible = value;
1790         break;
1791     case SCI_POLYLINE:
1792         pPOLYLINE_FEATURE (pobjUID)->visible = value;
1793         break;
1794     case SCI_RECTANGLE:
1795         pRECTANGLE_FEATURE (pobjUID)->visible = value;
1796         break;
1797     case SCI_SURFACE:
1798         pSURFACE_FEATURE (pobjUID)->visible = value;
1799         break;
1800     case SCI_SEGS:
1801         pSEGS_FEATURE (pobjUID)->visible = value;
1802         break;
1803     case SCI_FEC:
1804         pFEC_FEATURE (pobjUID)->visible = value;
1805         break;
1806     case SCI_GRAYPLOT:
1807         pGRAYPLOT_FEATURE (pobjUID)->visible = value;
1808         break;
1809     case SCI_TEXT:
1810         pTEXT_FEATURE (pobjUID)->visible = value;
1811         break;
1812     case SCI_AXES:
1813         pAXES_FEATURE (pobjUID)->visible = value;
1814         break;
1815     case SCI_AGREG:
1816         pAGREG_FEATURE (pobjUID)->visible = value;
1817         break;
1818     case SCI_LABEL: /* F.Leray 28.05.04 */
1819         return sciInitVisibility( pLABEL_FEATURE(pobjUID)->text, value ) ;
1820         break;
1821     case SCI_UIMENU:
1822     case SCI_UICONTROL:
1823     default:
1824         return -1 ;
1825         break;
1826     }
1827 #endif
1828     return 0 ;
1829 }
1830
1831 /**sciSetVisibility*/
1832 int
1833 sciSetVisibility (char * pobjUID, BOOL value)
1834 {
1835     if ( sciGetVisibility( pobjUID ) == value )
1836     {
1837         /* nothing to do */
1838         return 1 ;
1839     }
1840     return sciInitVisibility( pobjUID, value ) ;
1841
1842 }
1843
1844
1845 int sciInitResize( char * pobjUID, BOOL value )
1846 {
1847     // FIXME
1848     abort();
1849 #if 0
1850
1851     switch (sciGetEntityType (pobjUID))
1852     {
1853     case SCI_FIGURE:
1854         if (isFigureModel(pobjUID))
1855         {
1856             pFIGURE_FEATURE(pobjUID)->pModelData->autoResizeMode = value;
1857         }
1858         else
1859         {
1860             sciSetJavaAutoResizeMode(pobjUID, value);
1861         }
1862         break;
1863     case SCI_SUBWIN:
1864         sciInitResize(sciGetParentFigure(pobjUID), value);
1865         break;
1866     case SCI_TEXT:
1867     case SCI_LEGEND:
1868     case SCI_ARC:
1869     case SCI_SEGS:
1870     case SCI_FEC:
1871     case SCI_GRAYPLOT:
1872     case SCI_POLYLINE:
1873     case SCI_RECTANGLE:
1874     case SCI_SURFACE:
1875     case SCI_AXES:
1876     case SCI_AGREG:
1877     case SCI_LABEL: /* F.Leray 28.05.04 */
1878     case SCI_UIMENU:
1879     default:
1880         printSetGetErrorMessage("auto_resize");
1881         return -1 ;
1882         break;
1883     }
1884 #endif
1885     return 0 ;
1886 }
1887
1888 /**sciSetResize
1889  * Tunrs ON or OFF the autoresizing mode (when the window is resized by user)
1890  * @param char * pobjUID: the pointer to the entity
1891  * @param BOOL value: the value of the switch
1892  */
1893 int
1894 sciSetResize (char * pobjUID, BOOL value)
1895 {
1896
1897     if ( sciGetResize( pobjUID ) == value )
1898     {
1899         /* nothing to do */
1900         return 1 ;
1901     }
1902     return sciInitResize( pobjUID, value ) ;
1903
1904 }
1905
1906
1907
1908 int sciInitName(char * pobjUID, char * newName)
1909 {
1910     // FIXME
1911     abort();
1912 #if 0
1913         switch (sciGetEntityType (pobjUID))
1914     {
1915     case SCI_FIGURE:
1916     {
1917         int newNameLength;
1918
1919         /* first case newName is NULL */
1920         if (newName == NULL)
1921         {
1922             /* Just set an empty title for the physical window if needed */
1923             if (!isFigureModel(pobjUID))
1924             {
1925                 sciSetJavaTitle(pobjUID, "");
1926             }
1927
1928             return 0;
1929         }
1930
1931         /* newName is a valid string */
1932         newNameLength = (int) strlen(newName);
1933
1934         /* Reallocate name */
1935         pFIGURE_FEATURE(pobjUID)->name = MALLOC( (newNameLength + 1) * sizeof(char) );
1936
1937         /* copy the string */
1938         strcpy(pFIGURE_FEATURE(pobjUID)->name, newName) ;
1939
1940         /* Update the name of the physical window if one exists */
1941         if (!isFigureModel(pobjUID))
1942         {
1943             /* In this case, we need to send the name to the physical window */
1944             if ( checkPercent(newName) == 0 )
1945             {
1946                 /* no %d, set the java title directly */
1947                 sciSetJavaTitle(pobjUID, pFIGURE_FEATURE(pobjUID)->name);
1948             }
1949             else
1950             {
1951                 /* a %d inside */
1952                 /* get the number digits of the window number */
1953                 int figureNumber = sciGetNum( pobjUID ) ;
1954                 int nbDigits = GET_NB_DIGITS( figureNumber ) ;
1955                 int realTitleLength = newNameLength + nbDigits - 2 ; /* -2 for the %d which is replaced */
1956                 char * realTitle = MALLOC( (realTitleLength + 1) * sizeof(char) ) ;
1957                 if ( realTitle == NULL )
1958                 {
1959                     Scierror(999, _("%s: No more memory.\n"),"sciSetName");
1960                     return -1 ;
1961                 }
1962                 sprintf( realTitle, newName, figureNumber ) ;
1963                 sciSetJavaTitle(pobjUID, realTitle);
1964                 FREE(realTitle) ;
1965             }
1966
1967
1968         }
1969
1970         return 0 ;
1971     }
1972     default:
1973         printSetGetErrorMessage("figure_name");
1974         return -1 ;
1975         break;
1976     }
1977 #endif
1978         return -1;
1979 }
1980
1981 /**sciSetName
1982  * Sets the name of the Figure
1983  * @param char * pobjUID: the pointer to the entity
1984  * @param char newName: a pointer to the string contening name
1985  * @return
1986  */
1987 int
1988 sciSetName(char * pobjUID, char * newName)
1989 {
1990     // FIXME
1991     abort();
1992 #if 0
1993         if (   newName != NULL
1994            && sciGetName(pobjUID) != NULL
1995            && strcmp(sciGetName(pobjUID), newName) == 0)
1996         {
1997                 // nothing to do
1998                 return 1;
1999         }
2000
2001         /* Check that the string contains at most one %d character */
2002         if (checkPercent(newName) < 0)
2003     {
2004         Scierror(999, _("Figure name may not contains any %% character, except a single %%d.\n")) ;
2005         return -1 ;
2006     }
2007
2008         /* Free the current name if needed */
2009         if (sciGetName(pobjUID) != NULL)
2010         {
2011                 FREE(pFIGURE_FEATURE(pobjUID)->name);
2012                 pFIGURE_FEATURE(pobjUID)->name = NULL;
2013         }
2014
2015         return sciInitName(pobjUID, newName);
2016 #endif
2017     return 1;
2018 }
2019
2020 int sciInitNum( char * pobjUID, int value )
2021 {
2022     // FIXME
2023     abort();
2024 #if 0
2025         switch (sciGetEntityType (pobjUID))
2026     {
2027     case SCI_FIGURE:
2028         pFIGURE_FEATURE(pobjUID)->number = value;
2029         break;
2030     default:
2031         printSetGetErrorMessage("figure_id");
2032         return -1 ;
2033         break;
2034     }
2035 #endif
2036     return 0 ;
2037 }
2038
2039 /**sciSetNum
2040  * Sets the number of the Figure.
2041  * @param char * pobjUID: the pointer to the entity
2042  * @param int value: the value of the number of the windows
2043  */
2044 int
2045 sciSetNum (char * pobjUID, int value )
2046 {
2047
2048     if ( sciGetNum(pobjUID) == value )
2049     {
2050         /* nothing to do */
2051         return 1 ;
2052     }
2053     return sciInitNum( pobjUID, value ) ;
2054
2055 }
2056
2057 int sciInitDimension( char * pobjUID, int newWidth, int newHeight )
2058 {
2059     // FIXME
2060     abort();
2061 #if 0
2062         switch (sciGetEntityType (pobjUID))
2063     {
2064     case SCI_FIGURE:
2065         if ( isFigureModel(pobjUID) )
2066         {
2067             pFIGURE_FEATURE(pobjUID)->pModelData->figureWidth  = newWidth ;
2068             pFIGURE_FEATURE(pobjUID)->pModelData->figureHeight = newHeight;
2069         }
2070         else
2071         {
2072             int size[2] = {newWidth, newHeight} ;
2073             return sciSetJavaFigureSize(pobjUID, size) ;
2074         }
2075         break;
2076     default:
2077         printSetGetErrorMessage("size");
2078         return -1 ;
2079         break;
2080     }
2081 #endif
2082     return 0 ;
2083 }
2084
2085
2086 /**sciSetDim
2087  * Sets the dimension of the Figure or Subwin
2088  * @param char * pobjUID: the pointer to the entity
2089  * @param int *pwidth: the width of the window dimension
2090  * @param int *pheight: the height of the window dimension
2091  * @return one of the EResizeStatus values.
2092  */
2093 int sciSetDimension( char * pobjUID, int newWidth, int newHeight )
2094 {
2095
2096     int width ;
2097     int height ;
2098     sciGetDim( pobjUID, &width, &height ) ;
2099     if ( width == newWidth && height == newHeight )
2100     {
2101         return 1 ;
2102     }
2103     return sciInitDimension( pobjUID, newWidth, newHeight ) ;
2104
2105 }
2106
2107 int sciInitWindowDim( char * pobjUID, int newWidth, int newHeight )
2108 {
2109     // FIXME
2110     abort();
2111 #if 0
2112         switch (sciGetEntityType (pobjUID))
2113     {
2114     case SCI_FIGURE:
2115         if ( pobjUID == getFigureModel() )
2116         {
2117             pFIGURE_FEATURE(pobjUID)->pModelData->windowWidth  = newWidth ;
2118             pFIGURE_FEATURE(pobjUID)->pModelData->windowHeight = newHeight;
2119         }
2120         else
2121         {
2122             int size[2] = {newWidth, newHeight} ;
2123             sciSetJavaWindowSize(pobjUID, size) ;
2124             //Check the new size
2125             sciGetJavaWindowSize(pobjUID, size);
2126             if(size[0]!=newWidth || size[1]!=newHeight)
2127             {
2128                 sciprint(_("WARNING : The size of the figure may not be as wide as you want.\n"));
2129             }
2130         }
2131         break;
2132     default:
2133         printSetGetErrorMessage("figure_size");
2134         return -1 ;
2135         break;
2136     }
2137 #endif
2138     return 0 ;
2139 }
2140
2141 int sciSetWindowDim( char * pobjUID, int newWidth, int newHeight )
2142 {
2143     if ( sciGetWindowWidth(pobjUID) == newWidth && sciGetWindowHeight(pobjUID) == newHeight )
2144     {
2145         /* nothing to do */
2146         return 1 ;
2147     }
2148     return sciInitWindowDim(pobjUID, newWidth, newHeight ) ;
2149 }
2150
2151 int sciInitScreenPosition( char * pobjUID, int pposx, int pposy )
2152 {
2153     // FIXME
2154     abort();
2155 #if 0
2156
2157     switch (sciGetEntityType (pobjUID))
2158     {
2159     case SCI_FIGURE:
2160         if ( pobjUID == getFigureModel() )
2161         {
2162             pFIGURE_FEATURE(pobjUID)->pModelData->windowPosition[0] = pposx ;
2163             pFIGURE_FEATURE(pobjUID)->pModelData->windowPosition[1] = pposy ;
2164         }
2165         else
2166         {
2167             int pos[2] = {pposx, pposy} ;
2168             sciSetJavaWindowPosition(pobjUID, pos) ;
2169         }
2170         return 0;
2171     default:
2172         printSetGetErrorMessage("figure_position");
2173         return -1;
2174         break;
2175     }
2176 #endif
2177     return 0;
2178 }
2179
2180 /**sciSetScreenPosition
2181  * Sets the position of the FIGURE (the window) in root.
2182  */
2183 int
2184 sciSetScreenPosition(char * pobjUID, int pposx, int pposy)
2185 {
2186     int posX ;
2187     int posY ;
2188     sciGetScreenPosition( pobjUID, &posX, &posY ) ;
2189     if ( posX == pposx && posY == pposy )
2190     {
2191         /* nothing to do */
2192         return 1 ;
2193     }
2194     return sciInitScreenPosition( pobjUID, pposx, pposy ) ;
2195
2196 }
2197
2198
2199 /*--------------------------------------------------------------------------*/
2200 /* sciSelectFirstSubwin                                                              */
2201 /* select under the first window found under the current figure                      */
2202 /*--------------------------------------------------------------------------*/
2203 void sciSelectFirstSubwin( char * parentFigure )
2204 {
2205     // FIXME
2206     abort();
2207 #if 0
2208         sciSons * figureSons = sciGetSons ( parentFigure ) ;
2209     if ( figureSons != (sciSons *) NULL )
2210     {
2211         /* look for the first subwindow */
2212         while (   (figureSons->pnext != (sciSons *) NULL)
2213                   && (sciGetEntityType (figureSons->pointobj) != SCI_SUBWIN))
2214         {
2215             figureSons = figureSons->pnext;
2216         }
2217
2218         if( sciGetEntityType (figureSons->pointobj) == SCI_SUBWIN )
2219         {
2220             /* we found another valid subwindow */
2221             sciSetSelectedSubWin (figureSons->pointobj);
2222         }
2223         else
2224         {
2225             sciSetSelectedSubWin(NULL);
2226         }
2227     }
2228 #endif
2229 }
2230
2231
2232 int sciInitSelectedSubWin( char * psubwinobj )
2233 {
2234     // FIXME
2235     abort();
2236 #if 0
2237     sciSubWindow * ppSubWin = pSUBWIN_FEATURE ( psubwinobj ) ;
2238
2239     sciInitSelectedObject( psubwinobj ) ;
2240 #endif
2241     return 0 ;
2242 }
2243
2244 /**sciSetSelectedSubWin
2245  * Determines wich SubWin is selected or not. WARNING TO BE DEFINED.
2246  * It has been adapted to the MVC. Its should be implemented entirely
2247  * within the MVC (as the setGraphicObjectRelationship function).
2248  * @param char * psubwinobj: the pointer to the entity sub window
2249  * @return 0 if OK or -1 if NOT OK
2250  */
2251 int
2252 sciSetSelectedSubWin (char * psubwinobjUID)
2253 {
2254     char* type;
2255     char* parent;
2256
2257     getGraphicObjectProperty(psubwinobjUID, __GO_TYPE__, jni_string, &type);
2258
2259     /* Check that the object is an AXES */
2260     if (strcmp(type, __GO_AXES__) != 0)
2261     {
2262         Scierror(999, _("Handle is not a SubWindow.\n"));
2263         return -1;
2264     }
2265
2266     getGraphicObjectProperty(psubwinobjUID, __GO_PARENT__, jni_string, &parent);
2267
2268     setGraphicObjectProperty(parent, __GO_SELECTED_CHILD__, psubwinobjUID, jni_string, 1);
2269
2270     return 0;
2271 }
2272
2273 /*-------------------------------------------------------------------------------*/
2274 int sciInitSelectedObject( char * pobjUID )
2275 {
2276     sciAddUniqueSelectedSon(sciGetParent(pobjUID), pobjUID ) ;
2277     return 0 ;
2278 }
2279 /*-------------------------------------------------------------------------------*/
2280
2281 /**sciSetOriginalSubWin
2282  * DO NOT USE !!!
2283  * @param char * pfigure, the parent figure,
2284  * @param char * psubwin: the pointer to the entity subwindow
2285  * @return 0 if OK -1 if not
2286  */
2287 int
2288 sciSetOriginalSubWin (char * pfigure, char * psubwin)
2289 {
2290     // FIXME
2291     abort();
2292 #if 0
2293         pFIGURE_FEATURE(pfigure)->originalsubwin0011 = psubwin;
2294 #endif
2295     return 0;
2296 }
2297
2298 /**sciSetPoint
2299  * sets points of the entity, and a pointer to the number of points
2300  */
2301 /** MAJ pour le 3D DJ.Abdemouche 2003**/
2302 int
2303 sciSetPoint(char * pthis, double *tab, int *numrow, int *numcol)
2304 {
2305     char* type;
2306     int i,n1,k,k1,k2;
2307     double * pvx  = NULL ;
2308     double * pvy  = NULL ;
2309     double * pvz  = NULL ;
2310     double * pvfx = NULL ;
2311     double * pvfy = NULL ;
2312     double * pvfz = NULL ;
2313     int * pstyle = NULL;
2314
2315     getGraphicObjectProperty(pthis, __GO_TYPE__, jni_string, &type);
2316
2317     /*
2318      * switch over sciGetEntityType replaced by object type string comparisons
2319      * Still required as we have no better way to do this for the moment
2320      */
2321     if (strcmp(type, __GO_POLYLINE__) == 0)
2322     {
2323         BOOL result;
2324         int numElementsArray[2];
2325         int zCoordinatesSet;
2326
2327         if ( (*numcol != 3) && (*numcol != 2) && (*numcol != 0) )
2328         {
2329             Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
2330             return -1;
2331         }
2332
2333         /*
2334          * The coordinates array is re-allocated (if required) within the data model, testing whether
2335          * the new number of points is different in order to free/re-allocate is not needed anymore.
2336          * The 0-element array case is managed by the data model as well.
2337          */
2338
2339         if (*numcol == 0)
2340         {
2341             n1 = 0;
2342         }
2343         else
2344         {
2345             n1 = *numrow;
2346         }
2347
2348         /* The first element must be equal to 1 for a Polyline, the second is the polyline's number of vertices */
2349         numElementsArray[0] = 1;
2350         numElementsArray[1] = n1;
2351
2352         /* Resizes the data coordinates array if required */
2353         result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
2354
2355         /*
2356          * For now, the FALSE return value corresponds to a failed memory allocation,
2357          * which does not allow to discriminate between the failed allocation and non-existing
2358          * property conditions.
2359          */
2360         if (result == FALSE)
2361         {
2362             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2363             return -1;
2364         }
2365
2366         if ( *numcol > 0 )
2367         {
2368             setGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, tab, jni_double_vector, n1);
2369             setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, &tab[n1], jni_double_vector, n1);
2370
2371             if (*numcol == 3)
2372             {
2373                 setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, &tab[2*n1], jni_double_vector, n1);
2374                 zCoordinatesSet = 1;
2375             }
2376             else
2377             {
2378                 zCoordinatesSet = 0;
2379             }
2380
2381             /* Required for now to indicate that the z coordinates have been set or not */
2382             setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_int, 1);
2383         }
2384
2385         return 0;
2386     }
2387     else if (strcmp(type, __GO_RECTANGLE__) == 0)
2388     {
2389         double* currentUpperLeftPoint;
2390         double upperLeftPoint[3];
2391         int widthIndex = 2;
2392         int size = *numrow * *numcol;
2393
2394         if ( size != 5 && size != 4 )
2395         {
2396             Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),4,5,"z");
2397             return -1;
2398         }
2399
2400         upperLeftPoint[0] = tab[0];
2401         upperLeftPoint[1] = tab[1];
2402
2403         if ( size == 5 )
2404         {
2405             upperLeftPoint[2] = tab[2];
2406             widthIndex = 3;
2407         }
2408         else
2409         {
2410             /*
2411              * Needed in order to set the z coordinate if size == 4
2412              * Being able to set only the point's x and y coordinates values would avoid doing this.
2413              */
2414             getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
2415             upperLeftPoint[2] = currentUpperLeftPoint[2];
2416         }
2417
2418         setGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
2419
2420         /* check that the height and width are positive */
2421         if ( tab[widthIndex] < 0.0 || tab[widthIndex + 1] < 0.0 )
2422         {
2423             Scierror(999,"Width and height must be positive.\n") ;
2424             return -1 ;
2425         }
2426
2427         setGraphicObjectProperty(pthis, __GO_WIDTH__, &tab[widthIndex], jni_double, 1);
2428         setGraphicObjectProperty(pthis, __GO_HEIGHT__, &tab[widthIndex + 1], jni_double, 1);
2429
2430         return 0;
2431     }
2432     else if (strcmp(type, __GO_ARC__) == 0)
2433     {
2434         double startAngle;
2435         double endAngle;
2436         double upperLeftPoint[3];
2437         double width;
2438         double height;
2439         double* currentUpperLeftPoint;
2440         int size;
2441
2442         size = *numrow * *numcol;
2443
2444         if ((size != 7) && (size != 6))
2445         {
2446             Scierror(999, _("Number of elements must be %d (%d if z coordinate )\n"),6,7);
2447             return -1;
2448         }
2449
2450         upperLeftPoint[0] = tab[0];
2451         upperLeftPoint[1] = tab[1];
2452
2453         /*
2454          * Setting the data has been made consistent with how it is done for the Rectangle:
2455          * it takes into account the size of the input array instead of the parent Axes'
2456          * view property. Using the latter led to incorrectly set values when size and view
2457          * were not corresponding (for example when size==7, and view==2d).
2458          */
2459         if (size == 7)
2460         {
2461             upperLeftPoint[2] = tab[2];
2462             width = tab[3];
2463             height = tab[4];
2464             startAngle = DEG2RAD(tab[5]);
2465             endAngle = DEG2RAD(tab[6]);
2466         }
2467         else
2468         {
2469             /* Needed in order to set the z coordinate if size == 6 */
2470             getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
2471
2472             upperLeftPoint[2] = currentUpperLeftPoint[2];
2473             width = tab[2];
2474             height = tab[3];
2475             startAngle = DEG2RAD(tab[4]);
2476             endAngle = DEG2RAD(tab[5]);
2477         }
2478
2479         setGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
2480
2481         setGraphicObjectProperty(pthis, __GO_WIDTH__, &width, jni_double, 1);
2482         setGraphicObjectProperty(pthis, __GO_HEIGHT__, &height, jni_double, 1);
2483
2484         setGraphicObjectProperty(pthis, __GO_START_ANGLE__, &startAngle, jni_double, 1);
2485         setGraphicObjectProperty(pthis, __GO_END_ANGLE__, &endAngle, jni_double, 1);
2486
2487         return 0;
2488     }
2489     else if (strcmp(type, __GO_TEXT__) == 0)
2490     {
2491         char* parentAxes;
2492         double position[3];
2493         int iView = 0;
2494         int* piView = &iView;
2495
2496         if ((*numrow * *numcol != 2)&&(*numrow * *numcol != 3))
2497         {
2498             Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),2,3,"z");
2499             return -1;
2500         }
2501
2502         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
2503         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
2504
2505         position[0] = tab[0];
2506         position[1] = tab[1];
2507
2508         if (iView)
2509         {
2510             position[2] = tab[2];
2511         }
2512         else
2513         {
2514             /*
2515              * Required as the position has 3 coordinates, hence the z-coordinate
2516              * is set to its current value, which must be retrieved beforehand.
2517              * Avoiding doing this would require being able to set only the x and y
2518              * coordinates if required.
2519              */
2520             double* currentPosition;
2521             getGraphicObjectProperty(pthis, __GO_POSITION__, jni_double_vector, &currentPosition);
2522             position[2] = currentPosition[2];
2523         }
2524
2525         setGraphicObjectProperty(pthis, __GO_POSITION__, position, jni_double_vector, 3);
2526
2527         return 0;
2528     }
2529     else if (strcmp(type, __GO_SEGS__) == 0)
2530     {
2531         int numArrows;
2532         double* arrowPoints = NULL;
2533
2534         if ((*numcol != 3)&&(*numcol != 2))
2535         {
2536             Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
2537             return -1;
2538         }
2539
2540         if (*numrow % 2 != 0)
2541         {
2542             Scierror(999, _("Number of rows must be a multiple of 2.\n"));
2543             return -1;
2544         }
2545
2546
2547         numArrows = *numrow/2;
2548
2549         arrowPoints = (double*) MALLOC(3*numArrows*sizeof(double));
2550
2551         if (arrowPoints == NULL)
2552         {
2553             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2554             return -1;
2555         }
2556
2557         /*
2558          * Interlacing ought to be done in the MVC's coordinates
2559          * set function to avoid the additional code below.
2560          */
2561         for (i = 0; i < numArrows; i++)
2562         {
2563             arrowPoints[3*i] = tab[2*i];
2564             arrowPoints[3*i+1] = tab[2*numArrows+2*i];
2565
2566             if (*numcol == 3)
2567             {
2568                 arrowPoints[3*i+2] = tab[4*numArrows+2*i];
2569             }
2570             else
2571             {
2572                 arrowPoints[3*i+2] = 0.0;
2573             }
2574         }
2575
2576         setGraphicObjectProperty(pthis, __GO_NUMBER_ARROWS__, &numArrows, jni_int, 1);
2577
2578         setGraphicObjectProperty(pthis, __GO_BASE__, arrowPoints, jni_double_vector, 3*numArrows);
2579
2580         for (i = 0; i < numArrows; i++)
2581         {
2582             arrowPoints[3*i] = tab[2*i+1];
2583             arrowPoints[3*i+1] = tab[2*numArrows+2*i+1];
2584
2585             if (*numcol == 3)
2586             {
2587                 arrowPoints[3*i+2] = tab[4*numArrows+2*i+1];
2588             }
2589             else
2590             {
2591                 arrowPoints[3*i+2] = 0.0;
2592             }
2593         }
2594
2595         setGraphicObjectProperty(pthis, __GO_DIRECTION__, arrowPoints, jni_double_vector, 3*numArrows);
2596
2597         FREE(arrowPoints);
2598
2599         return 0;
2600     }
2601     /* DJ.A 2003 */
2602     /* SCI_SURFACE has been replaced by the MVC's FAC3D and PLOT3D */
2603     else if (strcmp(type, __GO_FAC3D__) == 0)
2604     {
2605         Scierror(999, _("Unhandled data field\n"));
2606         return -1;
2607     }
2608     else if (strcmp(type, __GO_PLOT3D__) == 0)
2609     {
2610         Scierror(999, _("Unhandled data field\n"));
2611         return -1;
2612     }
2613     else if (strcmp(type, __GO_MATPLOT__) == 0)
2614     {
2615         int nx;
2616         int ny;
2617         int gridSize[4];
2618         int result;
2619
2620         ny = *numrow;
2621         nx = *numcol;
2622
2623         /*
2624          * The number of points along each dimension is equal to the z data matrix's
2625          * corresponding dimension plus 1
2626          */
2627         gridSize[0] = nx + 1;
2628         gridSize[1] = 1;
2629         gridSize[2] = ny + 1;
2630         gridSize[3] = 1;
2631
2632         result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
2633
2634         if (result == FALSE)
2635         {
2636             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2637             return -1;
2638         }
2639
2640         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, tab, jni_double_vector, nx*ny);
2641     }
2642     else if (strcmp(type, __GO_FEC__) == 0)
2643     {
2644         BOOL result;
2645         int Nnode;
2646         if (*numcol != 3)
2647         {
2648             Scierror(999, _("Number of columns must be %d.\n"),3);
2649             return -1;
2650         }
2651
2652         Nnode = *numrow;
2653
2654         /* Resizes the data coordinates array if required */
2655         result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_VERTICES__, &Nnode, jni_int, 1);
2656
2657         if (result == FALSE)
2658         {
2659             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2660             return -1;
2661         }
2662
2663         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, tab, jni_double_vector, Nnode);
2664         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, &tab[Nnode], jni_double_vector, Nnode);
2665         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_VALUES__, &tab[2*Nnode], jni_double_vector, Nnode);
2666     }
2667     else if (strcmp(type, __GO_FIGURE__) == 0)
2668     {
2669         printSetGetErrorMessage("data");
2670         return -1;
2671     }
2672     else if (strcmp(type, __GO_AXES__) == 0)
2673     {
2674         printSetGetErrorMessage("data");
2675         return -1;
2676     }
2677     else if (strcmp(type, __GO_LEGEND__) == 0)
2678     {
2679         printSetGetErrorMessage("data");
2680         return -1;
2681     }
2682     else if (strcmp(type, __GO_AXIS__) == 0)
2683     {
2684         printSetGetErrorMessage("data");
2685         return -1;
2686     }
2687     else if (strcmp(type, __GO_COMPOUND__) == 0)
2688     {
2689         printSetGetErrorMessage("data");
2690         return -1;
2691     }
2692     /* F.Leray 28.05.04 */
2693     else if (strcmp(type, __GO_LABEL__) == 0)
2694     {
2695         printSetGetErrorMessage("data");
2696         return -1;
2697     }
2698     /*
2699      * Deactivated for now
2700      * Same condition as the default one
2701      */
2702 #if 0
2703 case SCI_UIMENU:
2704 #endif
2705     else
2706     {
2707         printSetGetErrorMessage("data");
2708         return -1;
2709     }
2710
2711     return 0;
2712 }
2713
2714 int sciInitdrawmode( BOOL mode )
2715 {
2716 #if 0
2717     static sciPointObj * pobj ;
2718     pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
2719     pSUBWIN_FEATURE(pobj)->visible = mode ;
2720     sciDrawObj(sciGetCurrentFigure ());
2721 #endif
2722     return 0;
2723 }
2724
2725 int
2726 sciSetdrawmode (BOOL mode)
2727 {
2728 // ???
2729 #if 0
2730     static sciPointObj * pobj ;
2731     pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
2732     if ( sciGetdrawmode( pobj ) == mode )
2733     {
2734         /* nothing to do */
2735         return 1 ;
2736     }
2737     return sciInitdrawmode( mode ) ;
2738 #endif
2739     return 0;
2740 }
2741
2742 /*----------------------------------------------------------------------------------*/
2743 /**
2744  * In new graphic style, select a window and create one if not already done.
2745  */
2746 int sciSetUsedWindow( int winNum )
2747 {
2748     // FIXME
2749     abort();
2750 #if 0
2751         return 1;
2752     /* select or create the window in the driver */
2753     if ( sciHasFigures() && sciGetNum( sciGetCurrentFigure() ) == winNum )
2754     {
2755         /* nothing to do */
2756         return 1 ;
2757     }
2758
2759     return sciInitUsedWindow( winNum ) ;
2760 #endif
2761     return 1;
2762 }
2763
2764 /*----------------------------------------------------------------------------------*/
2765
2766
2767
2768 int sciInitIsFilled( char * pobjUID, BOOL isfilled )
2769 {
2770     // FIXME
2771     abort();
2772 #if 0
2773         switch (sciGetEntityType (pobjUID))
2774     {
2775     case SCI_LABEL:
2776         /* isfilled correspond to several properties in text object */
2777         sciInitIsBoxed(  pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
2778         sciInitIsLine(   pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
2779         return sciInitIsFilled( pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
2780     case SCI_SUBWIN:
2781         pSUBWIN_FEATURE(pobjUID)->axes.filled = isfilled;
2782         return 0;
2783     default:
2784         if(sciGetGraphicContext(pobjUID) != NULL)
2785         {
2786             sciGetGraphicContext(pobjUID)->isfilled = isfilled;
2787             return 0;
2788         }
2789     }
2790
2791     printSetGetErrorMessage("fill_mode");
2792 #endif
2793     return -1;
2794 }
2795
2796 /**sciSetIsFilled
2797  * Sets the filled line existence
2798  */
2799 int
2800 sciSetIsFilled (char * pobjUID, BOOL isfilled)
2801 {
2802
2803     if ( sciGetIsFilled( pobjUID ) == isfilled )
2804     {
2805         return 1 ;
2806     }
2807     return sciInitIsFilled( pobjUID, isfilled ) ;
2808
2809 }
2810
2811
2812 int sciInitBoxType( char * pobjUID, EAxesBoxType type )
2813 {
2814     // FIXME
2815     abort();
2816 #if 0
2817         switch (sciGetEntityType (pobjUID))
2818     {
2819     case SCI_SUBWIN:
2820         pSUBWIN_FEATURE(pobjUID)->axes.rect = type ;
2821         /* redondant information in scilab :'( */
2822         switch ( type )
2823         {
2824         case BT_OFF:
2825             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 0 ;
2826             break ;
2827         case BT_ON:
2828             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 4 ;
2829             break ;
2830         case BT_HIDDEN_AXES:
2831             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 2 ;
2832             break ;
2833         case BT_BACK_HALF:
2834             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 3 ;
2835             break ;
2836         }
2837         return 0;
2838         break;
2839     default:
2840         printSetGetErrorMessage("box_type");
2841         return -1 ;
2842         break;
2843     }
2844 #endif
2845         return -1 ;
2846 }
2847
2848 /* set the property of the axes box  */
2849 int sciSetBoxType( char * pobjUID, EAxesBoxType type )
2850 {
2851
2852     if ( sciGetBoxType( pobjUID ) == type )
2853     {
2854         return 1 ;
2855     }
2856     return sciInitBoxType( pobjUID, type ) ;
2857
2858 }
2859
2860
2861 int sciInitIsBoxed( char * pobjUID, BOOL isboxed )
2862 {
2863     // FIXME
2864     abort();
2865 #if 0
2866         switch (sciGetEntityType (pobjUID))
2867     {
2868     case SCI_TEXT:
2869         pTEXT_FEATURE(pobjUID)->isboxed = isboxed;
2870         return 0;
2871         break;
2872     case SCI_SUBWIN:
2873         Scierror(999, _("%s: please use %s instead.\n"),"sciSetIsBoxed","sciSetBoxType");
2874         if ( isboxed )
2875         {
2876             pSUBWIN_FEATURE(pobjUID)->axes.rect = BT_ON ;
2877         }
2878         else
2879         {
2880             pSUBWIN_FEATURE(pobjUID)->axes.rect = BT_OFF ;
2881         }
2882         return 0;
2883         break;
2884     case SCI_LABEL:
2885     case SCI_POLYLINE:
2886     case SCI_RECTANGLE:
2887     case SCI_ARC:
2888     case SCI_FIGURE:
2889     case SCI_SURFACE:
2890     case SCI_AXES:
2891     case SCI_LEGEND:
2892     case SCI_SEGS:
2893     case SCI_FEC:
2894     case SCI_GRAYPLOT:
2895     case SCI_AGREG:
2896     case SCI_UIMENU:
2897     default:
2898         printSetGetErrorMessage("box_type");
2899         return -1;
2900         break;
2901     }
2902 #endif
2903         return -1 ;
2904 }
2905
2906 /**sciSetIsBoxed
2907  * Sets the box existence
2908  */
2909 int
2910 sciSetIsBoxed (char * pobjUID, BOOL isboxed)
2911 {
2912
2913     if ( sciGetIsBoxed( pobjUID ) == isboxed )
2914     {
2915         return 1 ;
2916     }
2917     return sciInitIsBoxed( pobjUID, isboxed ) ;
2918
2919 }
2920
2921
2922 int
2923 sciInitNbXSubTics(char * pobjUID, int nbsubtics)
2924 {
2925     // FIXME
2926     abort();
2927 #if 0
2928         switch (sciGetEntityType (pobjUID))
2929     {
2930     case SCI_SUBWIN:
2931         pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[0] = nbsubtics;
2932         break;
2933     default:
2934         printSetGetErrorMessage("subwin_type required");
2935         return -1 ;
2936         break;
2937     }
2938 #endif
2939     return 0 ;
2940 }
2941
2942 /**sciSetNbXSubTics
2943  * Sets the number of x subticks
2944  */
2945 int
2946 sciSetNbXSubTics(char * pobjUID, int nbsubtics)
2947 {
2948     int curr_nbsubtics[3];
2949
2950     sciGetNbSubTics( pobjUID,  curr_nbsubtics);
2951
2952     if ( curr_nbsubtics[0] == nbsubtics )
2953     {
2954         return 1 ;
2955     }
2956     return sciInitNbXSubTics( pobjUID, nbsubtics ) ;
2957 }
2958
2959 int
2960 sciInitNbYSubTics(char * pobjUID, int nbsubtics)
2961 {
2962 // FIXME
2963     abort();
2964 #if 0
2965     switch (sciGetEntityType (pobjUID))
2966     {
2967     case SCI_SUBWIN:
2968         pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[1] = nbsubtics;
2969         break;
2970     default:
2971         printSetGetErrorMessage("subwin_type required");
2972         return -1 ;
2973         break;
2974     }
2975 #endif
2976     return 0 ;
2977 }
2978
2979 /**sciSetNbYSubTics
2980  * Sets the number of y subticks
2981  */
2982 int
2983 sciSetNbYSubTics(char * pobjUID, int nbsubtics)
2984 {
2985     int curr_nbsubtics[3];
2986
2987     sciGetNbSubTics( pobjUID,  curr_nbsubtics);
2988
2989     if ( curr_nbsubtics[1] == nbsubtics )
2990     {
2991         return 1 ;
2992     }
2993     return sciInitNbYSubTics( pobjUID, nbsubtics ) ;
2994 }
2995
2996 int
2997 sciInitNbZSubTics(char * pobjUID, int nbsubtics)
2998 {
2999     // FIXME
3000     abort();
3001 #if 0
3002         switch (sciGetEntityType (pobjUID))
3003     {
3004     case SCI_SUBWIN:
3005         pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[2] = nbsubtics;
3006         break;
3007     default:
3008         printSetGetErrorMessage("subwin_type required");
3009         return -1 ;
3010         break;
3011     }
3012 #endif
3013     return 0 ;
3014 }
3015
3016 /**sciSetNbZSubTics
3017  * Sets the number of x subticks
3018  */
3019 int
3020 sciSetNbZSubTics(char * pobjUID, int nbsubtics)
3021 {
3022     int curr_nbsubtics[3];
3023
3024     sciGetNbSubTics( pobjUID,  curr_nbsubtics);
3025
3026     if ( curr_nbsubtics[2] == nbsubtics )
3027     {
3028         return 1 ;
3029     }
3030     return sciInitNbZSubTics( pobjUID, nbsubtics ) ;
3031 }
3032
3033
3034 int
3035 sciSetInterpVector(char * pobjUID, int size, int * value)
3036 {
3037     // FIXME
3038     abort();
3039 #if 0
3040         int i;
3041
3042     FREE(pPOLYLINE_FEATURE(pobjUID)->scvector);
3043
3044     if((pPOLYLINE_FEATURE(pobjUID)->scvector = MALLOC(size*sizeof(int)))==NULL){
3045         Scierror(999, _("%s: No more memory.\n"), "sciSetInterpVector") ;
3046         return -1;
3047     }
3048
3049     for(i=0;i<size;i++)
3050         pPOLYLINE_FEATURE(pobjUID)->scvector[i] = value[i];
3051 #endif
3052     return 0;
3053 }
3054
3055 int sciInitAutoRotation( char * pobjUID, BOOL value )
3056 {
3057     // FIXME
3058     abort();
3059 #if 0
3060         switch (sciGetEntityType (pobjUID))
3061     {
3062     case SCI_LABEL:
3063         pLABEL_FEATURE(pobjUID)->auto_rotation = value ;
3064         return 0;
3065     case SCI_POLYLINE:
3066     case SCI_RECTANGLE:
3067     case SCI_ARC:
3068     case SCI_TEXT:
3069     case SCI_FIGURE:
3070     case SCI_SUBWIN:
3071     case SCI_SURFACE:
3072     case SCI_AXES:
3073     case SCI_FEC:
3074     case SCI_SEGS:
3075     case SCI_LEGEND:
3076     case SCI_GRAYPLOT:
3077     case SCI_AGREG:
3078     case SCI_UIMENU:
3079     default:
3080         printSetGetErrorMessage("auto_rotation");
3081         return -1 ;
3082         break;
3083     }
3084 #endif
3085         return -1;
3086
3087 }
3088
3089 /* set the auto_rotation property of an object */
3090 int sciSetAutoRotation ( char * pobjUID, BOOL value )
3091 {
3092
3093     if ( sciGetAutoRotation( pobjUID ) == value )
3094     {
3095         /* nothing to do */
3096         return 1 ;
3097     }
3098     return sciInitAutoRotation( pobjUID, value ) ;
3099
3100 }
3101
3102
3103 int sciInitAutoPosition( char * pobjUID, BOOL value )
3104 {
3105     // FIXME
3106     abort();
3107 #if 0
3108         switch (sciGetEntityType (pobjUID))
3109     {
3110     case SCI_LABEL:
3111         pLABEL_FEATURE(pobjUID)->auto_position = value ;
3112         return 0;
3113     case SCI_POLYLINE:
3114     case SCI_RECTANGLE:
3115     case SCI_ARC:
3116     case SCI_TEXT:
3117     case SCI_FIGURE:
3118     case SCI_SUBWIN:
3119     case SCI_SURFACE:
3120     case SCI_AXES:
3121     case SCI_FEC:
3122     case SCI_SEGS:
3123     case SCI_LEGEND:
3124     case SCI_GRAYPLOT:
3125     case SCI_AGREG:
3126     case SCI_UIMENU:
3127     default:
3128         printSetGetErrorMessage("auto_position");
3129         return -1 ;
3130         break;
3131     }
3132 #endif
3133
3134 }
3135
3136 /* set the auto_position property of an object */
3137 int sciSetAutoPosition ( char * pobjUID, BOOL value )
3138 {
3139
3140     if ( sciGetAutoPosition( pobjUID ) == value )
3141     {
3142         /* nothing to do */
3143         return 1 ;
3144     }
3145     return sciInitAutoPosition( pobjUID, value ) ;
3146
3147 }
3148
3149 /*---------------------------------------------------------------------------*/
3150 int checkPercent( char * string )
3151 {
3152     /* check for the percent in the string */
3153     char * firstPercent  = strchr( string, '%' ) ;
3154
3155     if ( firstPercent == NULL )
3156     {
3157         /* no % character found */
3158         return 0 ;
3159     }
3160     else if ( firstPercent[1] != 'd' )
3161     {
3162         /* a %something with something != d has been found */
3163         return -1 ;
3164     }
3165     else
3166     {
3167         /* here we have found a first %d, check if there is not any more % */
3168         firstPercent++ ;
3169         firstPercent = strchr( firstPercent, '%' ) ;
3170         if ( firstPercent == NULL )
3171         {
3172             /* no other % character found */
3173             return 1 ;
3174         }
3175         else
3176         {
3177             return -1 ;
3178         }
3179     }
3180 }
3181 /*---------------------------------------------------------------------------*/
3182 int sciInitAutoSize( char * pobjUID, BOOL autoSize )
3183 {
3184 // FIXME
3185 #if 0
3186     switch ( sciGetEntityType (pobjUID) )
3187     {
3188     case SCI_TEXT:
3189         pTEXT_FEATURE(pobjUID)->autoSize = autoSize ;
3190         return 0 ;
3191     default:
3192         printSetGetErrorMessage("text_box_mode");
3193         return -1 ;
3194         break;
3195     }
3196 #endif
3197     return -1;
3198
3199 }
3200 /*---------------------------------------------------------------------------*/
3201 int sciSetAutoSize( char * pobjUID, BOOL autoSize )
3202 {
3203     if ( sciGetAutoSize( pobjUID ) == autoSize )
3204     {
3205         /* nothing to do */
3206         return 1 ;
3207     }
3208     return sciInitAutoSize( pobjUID, autoSize ) ;
3209 }
3210 /*-----------------------------------------------------------------------------------*/
3211 int sciInitAlignment( char * pobjUID, sciTextAlignment align )
3212 {
3213     // FIXME
3214     abort();
3215 #if 0
3216         switch (sciGetEntityType (pobjUID))
3217     {
3218     case SCI_TEXT:
3219         pTEXT_FEATURE(pobjUID)->stringsAlign = align ;
3220         return 0 ;
3221     default:
3222         printSetGetErrorMessage("alignment");
3223         return -1 ;
3224     }
3225 #endif
3226
3227 }
3228 /*-----------------------------------------------------------------------------------*/
3229 int sciSetAlignment( char * pobjUID, sciTextAlignment align )
3230 {
3231     if ( sciGetAlignment( pobjUID ) == align )
3232     {
3233         /* nothing to do */
3234         return 1 ;
3235     }
3236     return sciInitAlignment( pobjUID, align ) ;
3237 }
3238 /*-----------------------------------------------------------------------------------*/
3239 int sciInitUserSize( char * pobjUID, double width, double height )
3240 {
3241     // FIXME
3242     abort();
3243 #if 0
3244         switch( sciGetEntityType( pobjUID ) )
3245     {
3246     case SCI_TEXT:
3247         pTEXT_FEATURE(pobjUID)->userSize[0] = width ;
3248         pTEXT_FEATURE(pobjUID)->userSize[1] = height ;
3249         return 0 ;
3250     default:
3251         printSetGetErrorMessage("text_box");
3252         return -1 ;
3253     }
3254 #endif
3255         return -1;
3256 }
3257 /*-----------------------------------------------------------------------------------*/
3258 int sciSetUserSize( char * pobjUID, double width, double height )
3259 {
3260     double curWidth  ;
3261     double curHeight ;
3262     sciGetUserSize( pobjUID, &curWidth, &curHeight ) ;
3263     if ( curWidth == width && curHeight == height )
3264     {
3265         /* nothing to do */
3266         return 1 ;
3267     }
3268     return sciInitUserSize( pobjUID, width, height ) ;
3269 }
3270 /*-----------------------------------------------------------------------------------*/
3271 int sciInitCenterPos( char * pobjUID, BOOL newCP )
3272 {
3273     // FIXME
3274     abort();
3275 #if 0
3276         switch( sciGetEntityType( pobjUID ) )
3277     {
3278     case SCI_TEXT:
3279         pTEXT_FEATURE(pobjUID)->centeredPos = newCP ;
3280         return 0 ;
3281     default:
3282         printSetGetErrorMessage("data");
3283         return -1 ;
3284     }
3285 #endif
3286         return -1;
3287
3288 }
3289 /*-----------------------------------------------------------------------------------*/
3290 int sciSetCenterPos( char * pobjUID, BOOL newCP )
3291 {
3292     if ( sciGetCenterPos( pobjUID ) == newCP )
3293     {
3294         /* nothing to do */
3295         return 1 ;
3296     }
3297     return sciInitCenterPos( pobjUID, newCP ) ;
3298 }
3299 /*-----------------------------------------------------------------------------------*/
3300 int sciInitIs3d(  char * pobjUID, BOOL is3d )
3301 {
3302     // FIXME
3303     abort();
3304 #if 0
3305         switch( sciGetEntityType( pobjUID ) )
3306     {
3307     case SCI_SUBWIN:
3308         if ( is3d )
3309         {
3310             pSUBWIN_FEATURE (pobjUID)->is3d = TRUE ;
3311             Obj_RedrawNewAngle( pobjUID,
3312                                 pSUBWIN_FEATURE (pobjUID)->alpha_kp,
3313                                 pSUBWIN_FEATURE (pobjUID)->theta_kp ) ;
3314         }
3315         else
3316         {
3317             /* switch to 2d */
3318             if ( sciGetSurface(pobjUID) == NULL)
3319             {
3320                 pSUBWIN_FEATURE (pobjUID)->is3d = FALSE;
3321                 pSUBWIN_FEATURE (pobjUID)->project[2]= 0;
3322             }
3323             pSUBWIN_FEATURE (pobjUID)->theta_kp = pSUBWIN_FEATURE (pobjUID)->theta;
3324             pSUBWIN_FEATURE (pobjUID)->alpha_kp = pSUBWIN_FEATURE (pobjUID)->alpha;
3325             pSUBWIN_FEATURE (pobjUID)->alpha = 0.0;
3326             pSUBWIN_FEATURE (pobjUID)->theta = 270.0;
3327             pSUBWIN_FEATURE(pobjUID)->is3d = FALSE;
3328             return 0 ;
3329         }
3330         return 0 ;
3331     case SCI_TEXT:
3332         pTEXT_FEATURE( pobjUID )->is3d = is3d ;
3333         return 0 ;
3334     case SCI_LABEL:
3335         return sciInitIs3d( pLABEL_FEATURE( pobjUID )->text, is3d ) ;
3336     default:
3337         printSetGetErrorMessage("view");
3338         return -1 ;
3339     }
3340 #endif
3341         return -1;
3342 }
3343 /*-----------------------------------------------------------------------------------*/
3344 /**
3345  * Force an object to be displayed in 2d or 3d mode.
3346  */
3347 int sciSetIs3d( char * pobjUID, BOOL is3d )
3348 {
3349     if ( sciGetIs3d( pobjUID ) == is3d )
3350     {
3351         /* nothing to do */
3352         return 1 ;
3353     }
3354     return sciInitIs3d( pobjUID, is3d ) ;
3355 }
3356 /*-----------------------------------------------------------------------------------*/
3357 int sciInitHiddenColor( char * pobjUID, int newColor )
3358 {
3359     // FIXME
3360     abort();
3361 #if 0
3362         if(!sciCheckColorIndex(pobjUID, newColor)) { return -1;}
3363
3364     switch( sciGetEntityType( pobjUID ) )
3365     {
3366     case SCI_SUBWIN:
3367         pSUBWIN_FEATURE(pobjUID)->hiddencolor = newColor;
3368         return 0 ;
3369     case SCI_SURFACE:
3370         pSURFACE_FEATURE(pobjUID)->hiddencolor = newColor;
3371         return 0;
3372     default:
3373         printSetGetErrorMessage("hidden_color");
3374         return -1 ;
3375     }
3376 #endif
3377     return -1;
3378 }
3379 /*-----------------------------------------------------------------------------------*/
3380 int sciSetHiddenColor( char * pobjUID, int newColor )
3381 {
3382     if ( sciGetHiddenColor( pobjUID ) == newColor )
3383     {
3384         /* nothing to do */
3385         return 1 ;
3386     }
3387     return sciInitHiddenColor( pobjUID, newColor ) ;
3388 }
3389 /*-----------------------------------------------------------------------------------*/
3390 int sciInitHiddenAxisColor( char * pobjUID, int newColor )
3391 {
3392     // FIXME
3393     abort();
3394 #if 0
3395         int m = sciGetNumColors(pobjUID);
3396     if(newColor < -2 || newColor > m + 2) return 0;
3397
3398     newColor = sciSetGoodIndex(pobjUID,newColor);
3399
3400     switch( sciGetEntityType( pobjUID ) )
3401     {
3402     case SCI_SUBWIN:
3403         pSUBWIN_FEATURE(pobjUID)->axes.hiddenAxisColor = Max (0, Min (newColor - 1, m + 1));
3404         return 0 ;
3405     default:
3406         printSetGetErrorMessage("hidden_axis_color");
3407         return -1 ;
3408     }
3409 #endif
3410     return -1;
3411 }
3412 /*-----------------------------------------------------------------------------------*/
3413 int sciSetHiddenAxisColor( char * pobjUID, int newColor )
3414 {
3415     if ( sciGetHiddenAxisColor( pobjUID ) == newColor )
3416     {
3417         /* nothing to do */
3418         return 1 ;
3419     }
3420     return sciInitHiddenAxisColor( pobjUID, newColor ) ;
3421 }
3422 /*-----------------------------------------------------------------------------------*/
3423 int sciInitGridStyle( char * pobjUID, int xStyle, int yStyle, int zStyle )
3424 {
3425     // FIXME
3426     abort();
3427 #if 0
3428         if (    !sciCheckColorIndex(pobjUID, xStyle)
3429             || !sciCheckColorIndex(pobjUID, yStyle)
3430             || !sciCheckColorIndex(pobjUID, zStyle))
3431     {
3432         return -1;
3433     }
3434
3435     switch( sciGetEntityType( pobjUID ) )
3436     {
3437     case SCI_SUBWIN:
3438         pSUBWIN_FEATURE(pobjUID)->grid[0] = xStyle ;
3439         pSUBWIN_FEATURE(pobjUID)->grid[1] = yStyle ;
3440         pSUBWIN_FEATURE(pobjUID)->grid[2] = zStyle ;
3441         return 0 ;
3442     default:
3443         printSetGetErrorMessage("grid");
3444         return -1 ;
3445     }
3446 #endif
3447     return -1;
3448 }
3449 /*-----------------------------------------------------------------------------------*/
3450 /**
3451  * Set the grid of an axes object
3452  */
3453 int sciSetGridStyle( char * pobjUID, int xStyle, int yStyle, int zStyle )
3454 {
3455     int curX ;
3456     int curY ;
3457     int curZ ;
3458     sciGetGridStyle( pobjUID, &curX, &curY, &curZ ) ;
3459     if ( curX == xStyle && curY == yStyle && curZ == zStyle )
3460     {
3461         /* nothing to do */
3462         return 1 ;
3463     }
3464     return sciInitGridStyle( pobjUID, xStyle, yStyle, zStyle ) ;
3465 }
3466 /*-----------------------------------------------------------------------------------*/
3467 /**
3468  * Set the viewport property of a figure.
3469  * Effective only if the auto_resize property is enable
3470  */
3471 int sciSetViewport( char * pobjUID, const int viewport[4] )
3472 {
3473     // FIXME
3474     abort();
3475 #if 0
3476         switch( sciGetEntityType( pobjUID ) )
3477     {
3478     case SCI_FIGURE:
3479         if (isFigureModel(pobjUID))
3480         {
3481             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[0] = viewport[0];
3482             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[1] = viewport[1];
3483             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[2] = viewport[2];
3484             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[3] = viewport[3];
3485         }
3486         else
3487         {
3488             sciSetJavaViewport(pobjUID, viewport);
3489         }
3490         return 0;
3491     default:
3492         printSetGetErrorMessage("viewport");
3493         return -1 ;
3494     }
3495 #endif
3496         return -1;
3497 }
3498 /*-----------------------------------------------------------------------------------*/
3499 int sciInitInfoMessage(char * pobjUID, const char * newMessage)
3500 {
3501     // FIXME
3502     abort();
3503 #if 0
3504         if ( sciGetEntityType( pobjUID ) == SCI_FIGURE)
3505         {
3506
3507                 /* first case newName is NULL */
3508                 if (newMessage == NULL)
3509                 {
3510                         /* Just set an empty title for the physical window if needed */
3511                         if(isFigureModel(pobjUID))
3512                         {
3513                                 pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = NULL;
3514                         }
3515                         else
3516                         {
3517                                 sciSetJavaInfoMessage(pobjUID, "");
3518                         }
3519
3520                         return 0;
3521                 }
3522
3523                 if (isFigureModel(pobjUID))
3524                 {
3525                         /* Copy the message into the special data */
3526                         int newMessageLength = (int) strlen(newMessage);
3527                         pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = MALLOC((newMessageLength + 1) * sizeof(char));
3528                         if (pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage != NULL)
3529                         {
3530                                 strcpy(pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage, newMessage);
3531                         }
3532                 }
3533                 else
3534                 {
3535                         /* Copy in the Java data */
3536                         sciSetJavaInfoMessage(pobjUID, newMessage);
3537                 }
3538
3539                 return 0 ;
3540         }
3541         else
3542         {
3543                 printSetGetErrorMessage("info_message");
3544                 return -1;
3545         }
3546 #endif
3547         return -1;
3548 }
3549 /*-----------------------------------------------------------------------------------*/
3550 /**
3551  * Modify the string in the info bar of the graphic window
3552  */
3553 int sciSetInfoMessage( char * pobjUID, const char * newMessage )
3554 {
3555     // FIXME
3556     abort();
3557 #if 0
3558         if (isFigureModel(pobjUID) && pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage != NULL)
3559         {
3560                 FREE(pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage);
3561                 pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = NULL;
3562         }
3563         return sciInitInfoMessage(pobjUID, newMessage);
3564 #endif
3565     return -1;
3566 }
3567 /*-----------------------------------------------------------------------------------*/
3568 int sciInitEventHandler( char * pobjUID, char * name )
3569 {
3570     // FIXME
3571     abort();
3572 #if 0
3573         if( sciGetEntityType( pobjUID ) == SCI_FIGURE)
3574     {
3575         sciFigure * ppFigure = pFIGURE_FEATURE(pobjUID) ;
3576
3577         if ( ppFigure == NULL )
3578         {
3579             Scierror(999, _("%s: No more memory.\n"), "sciInitEventHandler") ;
3580             return -1 ;
3581         }
3582
3583         if ( ppFigure->eventHandler != NULL )
3584         {
3585             FREE(ppFigure->eventHandler);
3586         }
3587
3588         ppFigure->eventHandler = strdup(name);
3589
3590         /* Java is called to set the listener */
3591         if (!isFigureModel(pobjUID))
3592         {
3593             setFigureEventHandler(sciGetNum(pobjUID), name);
3594         }
3595
3596         if ( strcmp( name, "" ) == 0 )
3597         {
3598             sciInitIsEventHandlerEnable( pobjUID, FALSE ) ;
3599         }
3600
3601         return 0 ;
3602     }
3603     else
3604     {
3605         printSetGetErrorMessage("event_handler");
3606         return -1 ;
3607     }
3608 #endif
3609         return -1;
3610 }
3611 /*-----------------------------------------------------------------------------------*/
3612 int sciSetEventHandler( char * pobjUID, char * name )
3613 {
3614     if ( strcmp( sciGetEventHandler(pobjUID), name ) == 0 )
3615     {
3616         /* nothing to do */
3617         return 1 ;
3618     }
3619
3620     return sciInitEventHandler( pobjUID, name ) ;
3621 }
3622 /*-----------------------------------------------------------------------------------*/
3623 int sciInitIsEventHandlerEnable( char * pobjUID, BOOL enable )
3624 {
3625     // FIXME
3626     abort();
3627 #if 0
3628         if(sciGetEntityType( pobjUID ) == SCI_FIGURE)
3629     {
3630         sciFigure * ppFigure = pFIGURE_FEATURE(pobjUID) ;
3631         /*
3632         ** If we try to enable an empty Event Handler
3633         ** raise a Warning.
3634         */
3635         if (ppFigure != NULL
3636             && ppFigure->eventHandler != NULL
3637             && (strcmp(ppFigure->eventHandler, "") != 0 || enable == FALSE))
3638         {
3639             pFIGURE_FEATURE(pobjUID)->isEventHandlerEnable = enable ;
3640
3641             /* Java is called to enable or disable the listener */
3642             if (!isFigureModel(pobjUID))
3643             {
3644                 setFigureEventHandlerEnabled(sciGetNum(pobjUID), enable);
3645             }
3646         }
3647         else
3648         {
3649             Scierror(999, _("%s: Can't enable a void event handler.\n"), "sciInitEventHandler") ;
3650         }
3651         return 0 ;
3652     }
3653     else
3654     {
3655         printSetGetErrorMessage("event_handler");
3656         return -1 ;
3657     }
3658 #endif
3659         return -1;
3660 }
3661 /*-----------------------------------------------------------------------------------*/
3662 int sciSetIsEventHandlerEnable( char * pobjUID, BOOL enable )
3663 {
3664     if ( sciGetIsEventHandlerEnable(pobjUID) == enable )
3665     {
3666         /* nothing to do */
3667         return 1 ;
3668     }
3669
3670     return sciInitIsEventHandlerEnable( pobjUID, enable ) ;
3671 }
3672 /*-----------------------------------------------------------------------------------*/
3673 /**
3674  * Set data-bounds defined by the user.
3675  * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
3676  */
3677 int sciSetDataBounds( char * pobjUID, double bounds[6] )
3678 {
3679     // FIXME
3680     abort();
3681 #if 0
3682         int i;
3683     switch( sciGetEntityType(pobjUID) )
3684     {
3685     case SCI_SUBWIN:
3686         for ( i = 0 ; i < 6 ; i++ )
3687         {
3688             pSUBWIN_FEATURE(pobjUID)->SRect[i] = bounds[i] ;
3689         }
3690         return 0;
3691     case SCI_SURFACE:
3692         for ( i = 0 ; i < 6 ; i++ )
3693         {
3694             pSURFACE_FEATURE(pobjUID)->ebox[i] = bounds[i] ;
3695         }
3696         return 0;
3697     default:
3698         printSetGetErrorMessage("data_bounds");
3699         return -1 ;
3700
3701     }
3702 #endif
3703     return -1;
3704 }
3705 /*-----------------------------------------------------------------------------------*/
3706 /**
3707  * Set the displayed data bounds of a subwin object.
3708  */
3709 int sciSetRealDataBounds(char * pobjUID, const double bounds[6])
3710 {
3711      // FIXME
3712     abort();
3713 #if 0
3714        int i;
3715     switch( sciGetEntityType(pobjUID) )
3716     {
3717     case SCI_SUBWIN:
3718         for ( i = 0 ; i < 6 ; i++ )
3719         {
3720             pSUBWIN_FEATURE(pobjUID)->FRect[i] = bounds[i] ;
3721         }
3722         return 0;
3723     default:
3724         printSetGetErrorMessage("data_bounds");
3725         return -1 ;
3726
3727     }
3728 #endif
3729     return -1;
3730 }
3731 /*--------------------------------------------------------------------------------------------*/
3732 int sciInitViewingAngles( char * pobjUID, double alpha, double theta)
3733 {
3734      // FIXME
3735     abort();
3736 #if 0
3737        switch(sciGetEntityType(pobjUID))
3738     {
3739     case SCI_SUBWIN:
3740         pSUBWIN_FEATURE(pobjUID)->alpha = alpha;
3741         pSUBWIN_FEATURE(pobjUID)->theta = theta;
3742         return 0;
3743     default:
3744         printSetGetErrorMessage("rotation_angles");
3745         return -1;
3746     }
3747 #endif
3748        return -1;
3749 }
3750 /*-----------------------------------------------------------------------------------*/
3751 /**
3752  * Set the viewing angles (in degrees) of a subwindow
3753  */
3754 int sciSetViewingAngles( char * pobjUID, double alpha, double theta)
3755 {
3756     double curAlpha;
3757     double curTheta;
3758     sciGetViewingAngles(pobjUID, &curAlpha, &curTheta);
3759     if ( curAlpha == alpha && curTheta == theta )
3760     {
3761         /* nothing to do */
3762         return 1;
3763     }
3764
3765     return sciInitViewingAngles(pobjUID, alpha, theta) ;
3766
3767 }
3768 /*-----------------------------------------------------------------------------------*/
3769 /**
3770  * Set the info message of a figure with the information about rotation angles
3771  */
3772 int setInfoMessageWithRotationAngles(char * pFigure, double alpha, double theta)
3773 {
3774     // FIXME
3775     abort();
3776 #if 0
3777         /* keep this lower than 10*/
3778 #define ANGLE_DECIMAL_NUMBERS 1
3779     char angleDisplayFormat[5];
3780     int returnStatus = -1;
3781     double intPart;
3782     char * infoMessage = NULL;
3783     char formatedInfoMessage[29];
3784
3785     /* Size without numbers is 8 for "alpha = ", 10 for ", theta = " and 1 for the null terminating character */
3786     int infoMessageSize = 19;
3787
3788     /* set number of digits so format is %.xf where x is ANGLE_DECIMAL_NUMBERS */
3789     sprintf(angleDisplayFormat, "%%.%df", ANGLE_DECIMAL_NUMBERS);
3790
3791     /* compute size of alpha wich is the length of its int part plus 1 for the dot */
3792     /* and the number of decimals */
3793     modf(alpha, &intPart); /* get int part of alpha */
3794     infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
3795
3796     /* same for theta */
3797     modf(theta, &intPart);
3798     infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
3799
3800     /* We use also infomessage string to store the formated massage */
3801     /* The needed size might be 19 plus twice the format length so 8 => 27 */
3802
3803     /* Add alpha size, which is the size of its int part plus 1 for the dot and only  */
3804
3805     infoMessage = MALLOC(infoMessageSize * sizeof(char));
3806     if (infoMessage == NULL)
3807     {
3808         /* no more memory */
3809         return -1;
3810     }
3811
3812     /* Put the formats in the string */
3813     sprintf(formatedInfoMessage, "alpha = %s, theta = %s", angleDisplayFormat, angleDisplayFormat);
3814
3815     /* convert the formats into the angle values */
3816     sprintf(infoMessage, formatedInfoMessage, alpha, theta);
3817
3818     returnStatus = sciSetInfoMessage(pFigure, infoMessage) ;
3819
3820     FREE(infoMessage);
3821
3822     return returnStatus;
3823
3824 #undef ANGLE_DECIMAL_NUMBERS
3825 #endif
3826     return -1;
3827 }
3828 /*-----------------------------------------------------------------------------------*/
3829 /**
3830  * To set the pixmap mode of a figure to on or off
3831  */
3832 int sciInitPixmapMode(char * pobjUID, BOOL onOrOff)
3833 {
3834      // FIXME
3835     abort();
3836 #if 0
3837        switch(sciGetEntityType(pobjUID))
3838     {
3839     case SCI_FIGURE:
3840         pFIGURE_FEATURE(pobjUID)->pixmapMode = onOrOff;
3841         return 0;
3842     default:
3843         printSetGetErrorMessage("pixmap");
3844         return -1;
3845     }
3846 #endif
3847        return -1;
3848 }
3849 /*----------------------------------------------------------------------------------*/
3850 /**
3851  * To set the pixmap mode of a figure to on or off
3852  */
3853 int sciSetPixmapMode(char * pobjUID, BOOL onOrOff)
3854 {
3855     if (sciGetPixmapMode(pobjUID) == onOrOff)
3856     {
3857         /* Nothing to do */
3858         return 1;
3859     }
3860     return sciInitPixmapMode(pobjUID, onOrOff);
3861 }
3862 /*----------------------------------------------------------------------------------*/
3863 int sciInitTextPos( char * pobjUID, double posX, double posY, double posZ)
3864 {
3865     // FIXME
3866     abort();
3867 #if 0
3868         switch(sciGetEntityType(pobjUID))
3869     {
3870     case SCI_TEXT:
3871         pTEXT_FEATURE(pobjUID)->x = posX;
3872         pTEXT_FEATURE(pobjUID)->y = posY;
3873         pTEXT_FEATURE(pobjUID)->z = posZ;
3874         return 0;
3875     case SCI_LABEL:
3876         return sciInitTextPos(pLABEL_FEATURE(pobjUID)->text, posX, posY, posZ);
3877     default:
3878         printSetGetErrorMessage("data");
3879         return -1;
3880     }
3881 #endif
3882         return -1;
3883 }
3884 /*----------------------------------------------------------------------------------*/
3885 /**
3886  * Set the position of a label or text object.
3887  */
3888 int sciSetTextPos( char * pobjUID, double posX, double posY, double posZ)
3889 {
3890     double curPos[3];
3891     sciGetTextPos(pobjUID, curPos);
3892     if ( curPos[0] == posX && curPos[1] == posY && curPos[2] == posZ )
3893     {
3894         /* nothing to do */
3895         return 1;
3896     }
3897     return sciInitTextPos(pobjUID, posX, posY, posZ);
3898 }
3899 /*----------------------------------------------------------------------------------*/
3900 int sciInitLogFlags(char * pobjUID, char logFlags[3])
3901 {
3902     // FIXME
3903     abort();
3904 #if 0
3905         switch(sciGetEntityType(pobjUID))
3906     {
3907     case SCI_SUBWIN:
3908         pSUBWIN_FEATURE(pobjUID)->logflags[0] = logFlags[0];
3909         pSUBWIN_FEATURE(pobjUID)->logflags[1] = logFlags[1];
3910         pSUBWIN_FEATURE(pobjUID)->logflags[2] = logFlags[2];
3911
3912
3913
3914         return 0;
3915     default:
3916         printSetGetErrorMessage("log_flags");
3917         return -1;
3918     }
3919 #endif
3920         return -1;
3921 }
3922 /*----------------------------------------------------------------------------------*/
3923 /**
3924  * Set the log flags of a subwindow
3925  */
3926 int sciSetLogFlags(char * pobjUID, char logFlags[3])
3927 {
3928     char curLogFlags[3];
3929     int status;
3930     sciGetLogFlags(pobjUID, curLogFlags);
3931     if (   logFlags[0] == curLogFlags[0] && logFlags[1] == curLogFlags[1]
3932            && logFlags[2] == curLogFlags[2])
3933     {
3934         // nothing to do
3935         return 1;
3936     }
3937     status = sciInitLogFlags(pobjUID, logFlags);
3938
3939     // force redraw of all children of the object.
3940     if (status == 0 && pobjUID != getAxesModel())
3941     {
3942         forceHierarchyRedraw(pobjUID);
3943     }
3944
3945     return status;
3946 }
3947 /*----------------------------------------------------------------------------------*/
3948 int sciInitAutoTicks(char * pobjUID, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
3949 {
3950     // FIXME
3951     abort();
3952 #if 0
3953         switch(sciGetEntityType(pobjUID))
3954     {
3955     case SCI_SUBWIN:
3956         pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[0] = autoTicksX;
3957         pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[1] = autoTicksY;
3958         pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[2] = autoTicksZ;
3959         return 0;
3960     default:
3961         printSetGetErrorMessage("auto_ticks");
3962         return -1;
3963     }
3964 #endif
3965         return -1;
3966 }
3967 /*----------------------------------------------------------------------------------*/
3968 int sciSetAutoTicks(char * pobjUID, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
3969 {
3970     BOOL curAutoTicks[3];
3971     sciGetAutoTicks(pobjUID, curAutoTicks);
3972
3973     if (curAutoTicks[0] == autoTicksX && curAutoTicks[1] == autoTicksY && curAutoTicks[2] == autoTicksZ)
3974     {
3975         // nothing to do
3976         return 1;
3977     }
3978
3979     return sciInitAutoTicks(pobjUID, autoTicksX, autoTicksY, autoTicksZ);
3980
3981 }
3982 /*----------------------------------------------------------------------------------*/
3983 /**
3984  * Specify a new zoom box for a subwin object.
3985  * @param zoomBox [xMin, xMax, yMin, yMax, zMin, zMax] vector.
3986  */
3987 int sciSetZoomBox(char * pobjUID, const double zoomBox[6])
3988 {
3989     // FIXME
3990     abort();
3991 #if 0
3992         switch(sciGetEntityType(pobjUID))
3993     {
3994     case SCI_SUBWIN:
3995         pSUBWIN_FEATURE(pobjUID)->ZRect[0] = zoomBox[0];
3996         pSUBWIN_FEATURE(pobjUID)->ZRect[1] = zoomBox[1];
3997         pSUBWIN_FEATURE(pobjUID)->ZRect[2] = zoomBox[2];
3998         pSUBWIN_FEATURE(pobjUID)->ZRect[3] = zoomBox[3];
3999         pSUBWIN_FEATURE(pobjUID)->ZRect[4] = zoomBox[4];
4000         pSUBWIN_FEATURE(pobjUID)->ZRect[5] = zoomBox[5];
4001         return 0;
4002     default:
4003         printSetGetErrorMessage("zoom_box");
4004         return -1;
4005     }
4006 #endif
4007         return -1;
4008 }
4009 /*----------------------------------------------------------------------------------*/
4010 int sciInitImmediateDrawingMode(char * pobjUID, BOOL autoRedraw)
4011 {
4012      // FIXME
4013     abort();
4014 #if 0
4015        switch(sciGetEntityType(pobjUID))
4016     {
4017     case SCI_FIGURE:
4018         pFIGURE_FEATURE(pobjUID)->auto_redraw = autoRedraw;
4019         return 0;
4020     default:
4021         printSetGetErrorMessage("immediate_drawing");
4022         return -1;
4023     }
4024 #endif
4025        return -1;
4026 }
4027 /*----------------------------------------------------------------------------------*/
4028 int sciSetImmediateDrawingMode(char * pobjUID, BOOL autoRedraw)
4029 {
4030     // FIXME
4031     abort();
4032 #if 0
4033         if (sciGetImmediateDrawingMode(pobjUID) == autoRedraw)
4034     {
4035         // nothing to do
4036         return 1;
4037     }
4038     return sciInitImmediateDrawingMode(pobjUID, autoRedraw);
4039 #endif
4040     return -1;
4041 }
4042 /*----------------------------------------------------------------------------------*/
4043 int sciInitUseNurbs(char * pobjUID, BOOL useNurbs)
4044 {
4045     // FIXME
4046     abort();
4047 #if 0
4048         switch (sciGetEntityType(pobjUID))
4049     {
4050     case SCI_SUBWIN:
4051         pSUBWIN_FEATURE(pobjUID)->useNurbsForArcs = useNurbs;
4052         return 0;
4053     case SCI_ARC:
4054         pARC_FEATURE(pobjUID)->useNurbs = useNurbs;
4055         return 0;
4056     default:
4057         printSetGetErrorMessage("drawing_method");
4058         return -1;
4059     }
4060 #endif
4061         return -1;
4062 }
4063 /*----------------------------------------------------------------------------------*/
4064 /**
4065  * Return whether the drawing of an arc object uses nurbs or lines
4066  */
4067 int sciSetUseNurbs(char * pobjUID, BOOL useNurbs)
4068 {
4069     if (sciGetUseNurbs(pobjUID) == useNurbs)
4070     {
4071         // nothing to do
4072         return 1;
4073     }
4074     return sciInitUseNurbs(pobjUID, useNurbs);
4075 }
4076 /*----------------------------------------------------------------------------------*/
4077 int sciInitIsUsingFractionalMetrics(char * pobjUID, BOOL useFractionalMetrics)
4078 {
4079     // FIXME
4080     abort();
4081 #if 0
4082         sciFont * fontContext = sciGetFontContext(pobjUID);
4083     if (fontContext != NULL)
4084     {
4085         fontContext->useFractionalMetrics = useFractionalMetrics;
4086         return 0;
4087     }
4088     printSetGetErrorMessage("fractional_font");
4089 #endif
4090     return -1;
4091 }
4092 /*----------------------------------------------------------------------------------*/
4093 /**
4094  * Return whether an arc object uses fractional metrics for text display
4095  */
4096 int sciSetIsUsingFractionalMetrics(char * pobjUID, BOOL useFractionalMetrics)
4097 {
4098     if (sciGetIsUsingFractionalMetrics(pobjUID) == useFractionalMetrics)
4099     {
4100         // nothing to do
4101         return 1;
4102     }
4103     return sciInitIsUsingFractionalMetrics(pobjUID, useFractionalMetrics);
4104 }
4105 /*----------------------------------------------------------------------------------*/
4106 int sciInitColorRange(char * pobjUID, int subset[2])
4107 {
4108     // FIXME
4109     abort();
4110 #if 0
4111         switch (sciGetEntityType(pobjUID))
4112     {
4113     case SCI_FEC:
4114                 pFEC_FEATURE(pobjUID)->colminmax[0] = subset[0];
4115                 pFEC_FEATURE(pobjUID)->colminmax[1] = subset[1];
4116                 return 0;
4117     default:
4118         printSetGetErrorMessage("color_range");
4119                 return -1;
4120     }
4121 #endif
4122         return -1;
4123 }
4124 /*----------------------------------------------------------------------------------*/
4125 /**
4126  * Modify the subset of colormap bounds used by a particular object (colminmax).
4127  */
4128 int sciSetColorRange(char * pobjUID, int subset[2])
4129 {
4130
4131         int curColorRange[2];
4132         sciGetColorRange(pobjUID, curColorRange);
4133         if (curColorRange[0] == subset[0] && curColorRange[1] == subset[1])
4134         {
4135                 /* nothing to do */
4136                 return 1;
4137         }
4138
4139         return sciInitColorRange(pobjUID, subset);
4140
4141 }
4142 /*----------------------------------------------------------------------------------*/
4143 int sciInitOutsideColors(char * pobjUID, int colors[2])
4144 {
4145      // FIXME
4146     abort();
4147 #if 0
4148        switch (sciGetEntityType(pobjUID))
4149     {
4150     case SCI_FEC:
4151                 pFEC_FEATURE(pobjUID)->colout[0] = colors[0];
4152                 pFEC_FEATURE(pobjUID)->colout[1] = colors[1];
4153                 return 0;
4154     default:
4155         printSetGetErrorMessage("outside_color");
4156                 return -1;
4157     }
4158 #endif
4159        return -1;
4160 }
4161 /*----------------------------------------------------------------------------------*/
4162 /**
4163  * Modify the color to use for an objects when it uses index outside of the colormap (colout).
4164  */
4165 int sciSetOutsideColors(char * pobjUID, int colors[2])
4166 {
4167
4168         int curColors[2];
4169         sciGetOutsideColor(pobjUID, curColors);
4170         if (curColors[0] == colors[0] && curColors[1] == colors[1])
4171         {
4172                 /* nothing to do */
4173                 return 1;
4174         }
4175
4176     return sciInitOutsideColors(pobjUID, colors);
4177 }
4178 /*----------------------------------------------------------------------------------*/
4179 int sciInitZBounds(char * pobjUID, double bounds[2])
4180 {
4181     // FIXME
4182     abort();
4183 #if 0
4184         switch (sciGetEntityType(pobjUID))
4185     {
4186     case SCI_FEC:
4187                 pFEC_FEATURE(pobjUID)->zminmax[0] = bounds[0];
4188                 pFEC_FEATURE(pobjUID)->zminmax[1] = bounds[1];
4189                 return 0;
4190     default:
4191         printSetGetErrorMessage("z_bounds");
4192                 return -1;
4193     }
4194 #endif
4195         return -1;
4196 }
4197 /*----------------------------------------------------------------------------------*/
4198 /**
4199  * Modify the Z range used by a fec object (zminmax).
4200  */
4201 int sciSetZBounds(char * pobjUID, double bounds[2])
4202 {
4203     double curBounds[2];
4204         sciGetZBounds(pobjUID, curBounds);
4205         if (curBounds[0] == bounds[0] && curBounds[1] == bounds[1])
4206         {
4207                 /* nothing to do */
4208                 return 1;
4209         }
4210
4211         return sciInitZBounds(pobjUID, bounds);
4212 }
4213 /*----------------------------------------------------------------------------------*/
4214 int sciInitGridFront(char * pobjUID, BOOL gridFront)
4215 {
4216     // FIXME
4217     abort();
4218 #if 0
4219         switch (sciGetEntityType(pobjUID))
4220     {
4221         case SCI_SUBWIN:
4222                 pSUBWIN_FEATURE(pobjUID)->gridFront = gridFront;
4223                 return 0;
4224         default:
4225         printSetGetErrorMessage("grid_position");
4226                 return -1;
4227     }
4228 #endif
4229         return -1;
4230 }
4231 /*----------------------------------------------------------------------------------*/
4232 /**
4233  * Modify whether the grid is drawn in background or foreground.
4234  */
4235 int sciSetGridFront(char * pobjUID, BOOL gridFront)
4236 {
4237         if (sciGetGridFront(pobjUID) == gridFront)
4238         {
4239                 /* nothing to do */
4240                 return 1;
4241         }
4242         return sciInitGridFront(pobjUID, gridFront);
4243 }
4244 /*----------------------------------------------------------------------------------*/
4245 int sciInitAntialiasingQuality(char * pobjUID, int quality)
4246 {
4247     // FIXME
4248     abort();
4249 #if 0
4250         switch (sciGetEntityType(pobjUID))
4251     {
4252         case SCI_FIGURE:
4253                 if (isFigureModel(pobjUID))
4254                 {
4255                         pFIGURE_FEATURE(pobjUID)->pModelData->antialiasingQuality = quality;
4256                 }
4257                 else
4258                 {
4259                         sciSetJavaAntialiasingQuality(pobjUID, quality);
4260                 }
4261                 return 0;
4262     default:
4263         printSetGetErrorMessage("anti_aliasing");
4264                 return -1;
4265     }
4266 #endif
4267         return -1;
4268 }
4269 /*----------------------------------------------------------------------------------*/
4270 /**
4271  * Modify the quality of antialiasing or disable it.
4272  * If quality if 0, the antialiasing is disabled,
4273  * otherwise it might be either 1, 2, 4, 8 or 16 and then
4274  * specifies the number of pass for antialiasing.
4275  * @param quality positive integer.
4276  */
4277 int sciSetAntialiasingQuality(char * pobjUID, int quality)
4278 {
4279     if (sciGetAntialiasingQuality(pobjUID) == quality)
4280         {
4281                 /* nothing to do */
4282                 return 1;
4283         }
4284         return sciInitAntialiasingQuality(pobjUID, quality);
4285 }
4286 /*----------------------------------------------------------------------------------*/
4287 int sciInitLegendLocation(char * pobjUID, sciLegendPlace location)
4288 {
4289     // FIXME
4290     abort();
4291 #if 0
4292         switch (sciGetEntityType(pobjUID))
4293     {
4294         case SCI_LEGEND:
4295                 pLEGEND_FEATURE(pobjUID)->place = location;
4296                 return 0;
4297         default:
4298         printSetGetErrorMessage("legend_location");
4299                 return -1;
4300     }
4301 #endif
4302         return -1;
4303 }
4304 /*----------------------------------------------------------------------------------*/
4305 /**
4306  * Modify the legend position relatively to the subwindow
4307  */
4308 int sciSetLegendLocation(char * pobjUID, sciLegendPlace location)
4309 {
4310         if (sciGetLegendLocation(pobjUID) == location)
4311         {
4312                 /* nothing to do */
4313                 return 1;
4314         }
4315         return sciInitLegendLocation(pobjUID, location);
4316 }
4317 /*----------------------------------------------------------------------------------*/
4318 /**
4319  * Check that a color index is within the colormap range or not
4320  * @param pobjUID object conatining the color
4321  */
4322 BOOL sciCheckColorIndex(char * pobjUID, int colorIndex)
4323 {
4324     return (colorIndex >= -2) && (colorIndex <= sciGetNumColors(pobjUID) + 2);
4325 }
4326 /*----------------------------------------------------------------------------------*/