0bacff7540bed03c4f6624c69481b3f658c9370b
[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
1772
1773 int sciInitXorMode( char * pobjUID, int value )
1774 {
1775     // FIXME
1776     abort();
1777 #if 0
1778         switch (sciGetEntityType (pobjUID))
1779     {
1780     case SCI_FIGURE:
1781         (sciGetGraphicMode (pobjUID))->xormode = value;
1782         break;
1783     case SCI_SUBWIN:
1784         /* the value is inhirated by the parent */
1785         sciSetXorMode (sciGetParentFigure (pobjUID), value);
1786         break;
1787     case SCI_TEXT:
1788     case SCI_LEGEND:
1789     case SCI_ARC:
1790     case SCI_SEGS:
1791     case SCI_FEC:
1792     case SCI_GRAYPLOT:
1793     case SCI_POLYLINE:
1794     case SCI_RECTANGLE:
1795     case SCI_SURFACE:
1796     case SCI_AXES:
1797     case SCI_AGREG:
1798     case SCI_LABEL: /* F.Leray 28.05.04 */
1799     case SCI_UIMENU:
1800     default:
1801         printSetGetErrorMessage("graphic_mode");
1802         return -1 ;
1803         break;
1804     }
1805 #endif
1806     return 0 ;
1807 }
1808
1809 /**sciSetXorMode
1810  * Sets the xor mode
1811  * @param char * pobjUID: the pointer to the entity
1812  * @param int value: the value of the xor mode
1813  * @return
1814  * @author Djalel ABDEMOUCHE
1815  * @see sciGetXorMode
1816  */
1817 int
1818 sciSetXorMode (char * pobjUID, int value)
1819 {
1820
1821     if ( sciGetXorMode( pobjUID ) == value )
1822     {
1823         /* nothing to do */
1824         return 1 ;
1825     }
1826     return sciInitXorMode( pobjUID, value ) ;
1827
1828 }
1829
1830 int sciInitVisibility( char * pobjUID, BOOL value )
1831 {
1832     // FIXME
1833     abort();
1834 #if 0
1835
1836     switch (sciGetEntityType (pobjUID))
1837     {
1838     case SCI_FIGURE:
1839         pFIGURE_FEATURE (pobjUID)->visible = value;
1840         break;
1841     case SCI_SUBWIN:
1842         pSUBWIN_FEATURE (pobjUID)->visible = value;
1843         break;
1844     case SCI_LEGEND:
1845         pLEGEND_FEATURE (pobjUID)->visible = value;
1846         break;
1847     case SCI_ARC:
1848         pARC_FEATURE (pobjUID)->visible = value;
1849         break;
1850     case SCI_POLYLINE:
1851         pPOLYLINE_FEATURE (pobjUID)->visible = value;
1852         break;
1853     case SCI_RECTANGLE:
1854         pRECTANGLE_FEATURE (pobjUID)->visible = value;
1855         break;
1856     case SCI_SURFACE:
1857         pSURFACE_FEATURE (pobjUID)->visible = value;
1858         break;
1859     case SCI_SEGS:
1860         pSEGS_FEATURE (pobjUID)->visible = value;
1861         break;
1862     case SCI_FEC:
1863         pFEC_FEATURE (pobjUID)->visible = value;
1864         break;
1865     case SCI_GRAYPLOT:
1866         pGRAYPLOT_FEATURE (pobjUID)->visible = value;
1867         break;
1868     case SCI_TEXT:
1869         pTEXT_FEATURE (pobjUID)->visible = value;
1870         break;
1871     case SCI_AXES:
1872         pAXES_FEATURE (pobjUID)->visible = value;
1873         break;
1874     case SCI_AGREG:
1875         pAGREG_FEATURE (pobjUID)->visible = value;
1876         break;
1877     case SCI_LABEL: /* F.Leray 28.05.04 */
1878         return sciInitVisibility( pLABEL_FEATURE(pobjUID)->text, value ) ;
1879         break;
1880     case SCI_UIMENU:
1881     case SCI_UICONTROL:
1882     default:
1883         return -1 ;
1884         break;
1885     }
1886 #endif
1887     return 0 ;
1888 }
1889
1890 /**sciSetVisibility*/
1891 int
1892 sciSetVisibility (char * pobjUID, BOOL value)
1893 {
1894     if ( sciGetVisibility( pobjUID ) == value )
1895     {
1896         /* nothing to do */
1897         return 1 ;
1898     }
1899     return sciInitVisibility( pobjUID, value ) ;
1900
1901 }
1902
1903
1904 int sciInitResize( char * pobjUID, BOOL value )
1905 {
1906     // FIXME
1907     abort();
1908 #if 0
1909
1910     switch (sciGetEntityType (pobjUID))
1911     {
1912     case SCI_FIGURE:
1913         if (isFigureModel(pobjUID))
1914         {
1915             pFIGURE_FEATURE(pobjUID)->pModelData->autoResizeMode = value;
1916         }
1917         else
1918         {
1919             sciSetJavaAutoResizeMode(pobjUID, value);
1920         }
1921         break;
1922     case SCI_SUBWIN:
1923         sciInitResize(sciGetParentFigure(pobjUID), value);
1924         break;
1925     case SCI_TEXT:
1926     case SCI_LEGEND:
1927     case SCI_ARC:
1928     case SCI_SEGS:
1929     case SCI_FEC:
1930     case SCI_GRAYPLOT:
1931     case SCI_POLYLINE:
1932     case SCI_RECTANGLE:
1933     case SCI_SURFACE:
1934     case SCI_AXES:
1935     case SCI_AGREG:
1936     case SCI_LABEL: /* F.Leray 28.05.04 */
1937     case SCI_UIMENU:
1938     default:
1939         printSetGetErrorMessage("auto_resize");
1940         return -1 ;
1941         break;
1942     }
1943 #endif
1944     return 0 ;
1945 }
1946
1947 /**sciSetResize
1948  * Tunrs ON or OFF the autoresizing mode (when the window is resized by user)
1949  * @param char * pobjUID: the pointer to the entity
1950  * @param BOOL value: the value of the switch
1951  */
1952 int
1953 sciSetResize (char * pobjUID, BOOL value)
1954 {
1955
1956     if ( sciGetResize( pobjUID ) == value )
1957     {
1958         /* nothing to do */
1959         return 1 ;
1960     }
1961     return sciInitResize( pobjUID, value ) ;
1962
1963 }
1964
1965
1966
1967 int sciInitName(char * pobjUID, char * newName)
1968 {
1969     // FIXME
1970     abort();
1971 #if 0
1972         switch (sciGetEntityType (pobjUID))
1973     {
1974     case SCI_FIGURE:
1975     {
1976         int newNameLength;
1977
1978         /* first case newName is NULL */
1979         if (newName == NULL)
1980         {
1981             /* Just set an empty title for the physical window if needed */
1982             if (!isFigureModel(pobjUID))
1983             {
1984                 sciSetJavaTitle(pobjUID, "");
1985             }
1986
1987             return 0;
1988         }
1989
1990         /* newName is a valid string */
1991         newNameLength = (int) strlen(newName);
1992
1993         /* Reallocate name */
1994         pFIGURE_FEATURE(pobjUID)->name = MALLOC( (newNameLength + 1) * sizeof(char) );
1995
1996         /* copy the string */
1997         strcpy(pFIGURE_FEATURE(pobjUID)->name, newName) ;
1998
1999         /* Update the name of the physical window if one exists */
2000         if (!isFigureModel(pobjUID))
2001         {
2002             /* In this case, we need to send the name to the physical window */
2003             if ( checkPercent(newName) == 0 )
2004             {
2005                 /* no %d, set the java title directly */
2006                 sciSetJavaTitle(pobjUID, pFIGURE_FEATURE(pobjUID)->name);
2007             }
2008             else
2009             {
2010                 /* a %d inside */
2011                 /* get the number digits of the window number */
2012                 int figureNumber = sciGetNum( pobjUID ) ;
2013                 int nbDigits = GET_NB_DIGITS( figureNumber ) ;
2014                 int realTitleLength = newNameLength + nbDigits - 2 ; /* -2 for the %d which is replaced */
2015                 char * realTitle = MALLOC( (realTitleLength + 1) * sizeof(char) ) ;
2016                 if ( realTitle == NULL )
2017                 {
2018                     Scierror(999, _("%s: No more memory.\n"),"sciSetName");
2019                     return -1 ;
2020                 }
2021                 sprintf( realTitle, newName, figureNumber ) ;
2022                 sciSetJavaTitle(pobjUID, realTitle);
2023                 FREE(realTitle) ;
2024             }
2025
2026
2027         }
2028
2029         return 0 ;
2030     }
2031     default:
2032         printSetGetErrorMessage("figure_name");
2033         return -1 ;
2034         break;
2035     }
2036 #endif
2037         return -1;
2038 }
2039
2040 /**sciSetName
2041  * Sets the name of the Figure
2042  * @param char * pobjUID: the pointer to the entity
2043  * @param char newName: a pointer to the string contening name
2044  * @return
2045  */
2046 int
2047 sciSetName(char * pobjUID, char * newName)
2048 {
2049     // FIXME
2050     abort();
2051 #if 0
2052         if (   newName != NULL
2053            && sciGetName(pobjUID) != NULL
2054            && strcmp(sciGetName(pobjUID), newName) == 0)
2055         {
2056                 // nothing to do
2057                 return 1;
2058         }
2059
2060         /* Check that the string contains at most one %d character */
2061         if (checkPercent(newName) < 0)
2062     {
2063         Scierror(999, _("Figure name may not contains any %% character, except a single %%d.\n")) ;
2064         return -1 ;
2065     }
2066
2067         /* Free the current name if needed */
2068         if (sciGetName(pobjUID) != NULL)
2069         {
2070                 FREE(pFIGURE_FEATURE(pobjUID)->name);
2071                 pFIGURE_FEATURE(pobjUID)->name = NULL;
2072         }
2073
2074         return sciInitName(pobjUID, newName);
2075 #endif
2076     return 1;
2077 }
2078
2079 int sciInitNum( char * pobjUID, int value )
2080 {
2081     // FIXME
2082     abort();
2083 #if 0
2084         switch (sciGetEntityType (pobjUID))
2085     {
2086     case SCI_FIGURE:
2087         pFIGURE_FEATURE(pobjUID)->number = value;
2088         break;
2089     default:
2090         printSetGetErrorMessage("figure_id");
2091         return -1 ;
2092         break;
2093     }
2094 #endif
2095     return 0 ;
2096 }
2097
2098 /**sciSetNum
2099  * Sets the number of the Figure.
2100  * @param char * pobjUID: the pointer to the entity
2101  * @param int value: the value of the number of the windows
2102  */
2103 int
2104 sciSetNum (char * pobjUID, int value )
2105 {
2106
2107     if ( sciGetNum(pobjUID) == value )
2108     {
2109         /* nothing to do */
2110         return 1 ;
2111     }
2112     return sciInitNum( pobjUID, value ) ;
2113
2114 }
2115
2116 int sciInitDimension( char * pobjUID, int newWidth, int newHeight )
2117 {
2118     // FIXME
2119     abort();
2120 #if 0
2121         switch (sciGetEntityType (pobjUID))
2122     {
2123     case SCI_FIGURE:
2124         if ( isFigureModel(pobjUID) )
2125         {
2126             pFIGURE_FEATURE(pobjUID)->pModelData->figureWidth  = newWidth ;
2127             pFIGURE_FEATURE(pobjUID)->pModelData->figureHeight = newHeight;
2128         }
2129         else
2130         {
2131             int size[2] = {newWidth, newHeight} ;
2132             return sciSetJavaFigureSize(pobjUID, size) ;
2133         }
2134         break;
2135     default:
2136         printSetGetErrorMessage("size");
2137         return -1 ;
2138         break;
2139     }
2140 #endif
2141     return 0 ;
2142 }
2143
2144
2145 /**sciSetDim
2146  * Sets the dimension of the Figure or Subwin
2147  * @param char * pobjUID: the pointer to the entity
2148  * @param int *pwidth: the width of the window dimension
2149  * @param int *pheight: the height of the window dimension
2150  * @return one of the EResizeStatus values.
2151  */
2152 int sciSetDimension( char * pobjUID, int newWidth, int newHeight )
2153 {
2154
2155     int width ;
2156     int height ;
2157     sciGetDim( pobjUID, &width, &height ) ;
2158     if ( width == newWidth && height == newHeight )
2159     {
2160         return 1 ;
2161     }
2162     return sciInitDimension( pobjUID, newWidth, newHeight ) ;
2163
2164 }
2165
2166 int sciInitWindowDim( char * pobjUID, int newWidth, int newHeight )
2167 {
2168     // FIXME
2169     abort();
2170 #if 0
2171         switch (sciGetEntityType (pobjUID))
2172     {
2173     case SCI_FIGURE:
2174         if ( pobjUID == getFigureModel() )
2175         {
2176             pFIGURE_FEATURE(pobjUID)->pModelData->windowWidth  = newWidth ;
2177             pFIGURE_FEATURE(pobjUID)->pModelData->windowHeight = newHeight;
2178         }
2179         else
2180         {
2181             int size[2] = {newWidth, newHeight} ;
2182             sciSetJavaWindowSize(pobjUID, size) ;
2183             //Check the new size
2184             sciGetJavaWindowSize(pobjUID, size);
2185             if(size[0]!=newWidth || size[1]!=newHeight)
2186             {
2187                 sciprint(_("WARNING : The size of the figure may not be as wide as you want.\n"));
2188             }
2189         }
2190         break;
2191     default:
2192         printSetGetErrorMessage("figure_size");
2193         return -1 ;
2194         break;
2195     }
2196 #endif
2197     return 0 ;
2198 }
2199
2200 int sciSetWindowDim( char * pobjUID, int newWidth, int newHeight )
2201 {
2202     if ( sciGetWindowWidth(pobjUID) == newWidth && sciGetWindowHeight(pobjUID) == newHeight )
2203     {
2204         /* nothing to do */
2205         return 1 ;
2206     }
2207     return sciInitWindowDim(pobjUID, newWidth, newHeight ) ;
2208 }
2209
2210 int sciInitScreenPosition( char * pobjUID, int pposx, int pposy )
2211 {
2212     // FIXME
2213     abort();
2214 #if 0
2215
2216     switch (sciGetEntityType (pobjUID))
2217     {
2218     case SCI_FIGURE:
2219         if ( pobjUID == getFigureModel() )
2220         {
2221             pFIGURE_FEATURE(pobjUID)->pModelData->windowPosition[0] = pposx ;
2222             pFIGURE_FEATURE(pobjUID)->pModelData->windowPosition[1] = pposy ;
2223         }
2224         else
2225         {
2226             int pos[2] = {pposx, pposy} ;
2227             sciSetJavaWindowPosition(pobjUID, pos) ;
2228         }
2229         return 0;
2230     default:
2231         printSetGetErrorMessage("figure_position");
2232         return -1;
2233         break;
2234     }
2235 #endif
2236     return 0;
2237 }
2238
2239 /**sciSetScreenPosition
2240  * Sets the position of the FIGURE (the window) in root.
2241  */
2242 int
2243 sciSetScreenPosition(char * pobjUID, int pposx, int pposy)
2244 {
2245     int posX ;
2246     int posY ;
2247     sciGetScreenPosition( pobjUID, &posX, &posY ) ;
2248     if ( posX == pposx && posY == pposy )
2249     {
2250         /* nothing to do */
2251         return 1 ;
2252     }
2253     return sciInitScreenPosition( pobjUID, pposx, pposy ) ;
2254
2255 }
2256
2257
2258 /*--------------------------------------------------------------------------*/
2259 /* sciSelectFirstSubwin                                                              */
2260 /* select under the first window found under the current figure                      */
2261 /*--------------------------------------------------------------------------*/
2262 void sciSelectFirstSubwin( char * parentFigure )
2263 {
2264     // FIXME
2265     abort();
2266 #if 0
2267         sciSons * figureSons = sciGetSons ( parentFigure ) ;
2268     if ( figureSons != (sciSons *) NULL )
2269     {
2270         /* look for the first subwindow */
2271         while (   (figureSons->pnext != (sciSons *) NULL)
2272                   && (sciGetEntityType (figureSons->pointobj) != SCI_SUBWIN))
2273         {
2274             figureSons = figureSons->pnext;
2275         }
2276
2277         if( sciGetEntityType (figureSons->pointobj) == SCI_SUBWIN )
2278         {
2279             /* we found another valid subwindow */
2280             sciSetSelectedSubWin (figureSons->pointobj);
2281         }
2282         else
2283         {
2284             sciSetSelectedSubWin(NULL);
2285         }
2286     }
2287 #endif
2288 }
2289
2290
2291 int sciInitSelectedSubWin( char * psubwinobj )
2292 {
2293     // FIXME
2294     abort();
2295 #if 0
2296     sciSubWindow * ppSubWin = pSUBWIN_FEATURE ( psubwinobj ) ;
2297
2298     sciInitSelectedObject( psubwinobj ) ;
2299 #endif
2300     return 0 ;
2301 }
2302
2303 /**sciSetSelectedSubWin
2304  * Determines wich SubWin is selected or not. WARNING TO BE DEFINED.
2305  * It has been adapted to the MVC. Its should be implemented entirely
2306  * within the MVC (as the setGraphicObjectRelationship function).
2307  * @param char * psubwinobj: the pointer to the entity sub window
2308  * @return 0 if OK or -1 if NOT OK
2309  */
2310 int
2311 sciSetSelectedSubWin (char * psubwinobjUID)
2312 {
2313     char* type;
2314     char* parent;
2315
2316     getGraphicObjectProperty(psubwinobjUID, __GO_TYPE__, jni_string, &type);
2317
2318     /* Check that the object is an AXES */
2319     if (strcmp(type, __GO_AXES__) != 0)
2320     {
2321         Scierror(999, _("Handle is not a SubWindow.\n"));
2322         return -1;
2323     }
2324
2325     getGraphicObjectProperty(psubwinobjUID, __GO_PARENT__, jni_string, &parent);
2326
2327     setGraphicObjectProperty(parent, __GO_SELECTED_CHILD__, psubwinobjUID, jni_string, 1);
2328
2329     return 0;
2330 }
2331
2332 /*-------------------------------------------------------------------------------*/
2333 int sciInitSelectedObject( char * pobjUID )
2334 {
2335     sciAddUniqueSelectedSon(sciGetParent(pobjUID), pobjUID ) ;
2336     return 0 ;
2337 }
2338 /*-------------------------------------------------------------------------------*/
2339
2340 /**sciSetOriginalSubWin
2341  * DO NOT USE !!!
2342  * @param char * pfigure, the parent figure,
2343  * @param char * psubwin: the pointer to the entity subwindow
2344  * @return 0 if OK -1 if not
2345  */
2346 int
2347 sciSetOriginalSubWin (char * pfigure, char * psubwin)
2348 {
2349     // FIXME
2350     abort();
2351 #if 0
2352         pFIGURE_FEATURE(pfigure)->originalsubwin0011 = psubwin;
2353 #endif
2354     return 0;
2355 }
2356
2357 /**sciSetPoint
2358  * sets points of the entity, and a pointer to the number of points
2359  */
2360 /** MAJ pour le 3D DJ.Abdemouche 2003**/
2361 int
2362 sciSetPoint(char * pthis, double *tab, int *numrow, int *numcol)
2363 {
2364     char* type;
2365     int i,n1,k,k1,k2;
2366     double * pvx  = NULL ;
2367     double * pvy  = NULL ;
2368     double * pvz  = NULL ;
2369     double * pvfx = NULL ;
2370     double * pvfy = NULL ;
2371     double * pvfz = NULL ;
2372     int * pstyle = NULL;
2373
2374     getGraphicObjectProperty(pthis, __GO_TYPE__, jni_string, &type);
2375
2376     /*
2377      * switch over sciGetEntityType replaced by object type string comparisons
2378      * Still required as we have no better way to do this for the moment
2379      */
2380     if (strcmp(type, __GO_POLYLINE__) == 0)
2381     {
2382         BOOL result;
2383         int numElementsArray[2];
2384         int zCoordinatesSet;
2385
2386         if ( (*numcol != 3) && (*numcol != 2) && (*numcol != 0) )
2387         {
2388             Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
2389             return -1;
2390         }
2391
2392         /*
2393          * The coordinates array is re-allocated (if required) within the data model, testing whether
2394          * the new number of points is different in order to free/re-allocate is not needed anymore.
2395          * The 0-element array case is managed by the data model as well.
2396          */
2397
2398         if (*numcol == 0)
2399         {
2400             n1 = 0;
2401         }
2402         else
2403         {
2404             n1 = *numrow;
2405         }
2406
2407         /* The first element must be equal to 1 for a Polyline, the second is the polyline's number of vertices */
2408         numElementsArray[0] = 1;
2409         numElementsArray[1] = n1;
2410
2411         /* Resizes the data coordinates array if required */
2412         result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
2413
2414         /*
2415          * For now, the FALSE return value corresponds to a failed memory allocation,
2416          * which does not allow to discriminate between the failed allocation and non-existing
2417          * property conditions.
2418          */
2419         if (result == FALSE)
2420         {
2421             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2422             return -1;
2423         }
2424
2425         if ( *numcol > 0 )
2426         {
2427             setGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, tab, jni_double_vector, n1);
2428             setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, &tab[n1], jni_double_vector, n1);
2429
2430             if (*numcol == 3)
2431             {
2432                 setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, &tab[2*n1], jni_double_vector, n1);
2433                 zCoordinatesSet = 1;
2434             }
2435             else
2436             {
2437                 zCoordinatesSet = 0;
2438             }
2439
2440             /* Required for now to indicate that the z coordinates have been set or not */
2441             setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_int, 1);
2442         }
2443
2444         return 0;
2445     }
2446     else if (strcmp(type, __GO_RECTANGLE__) == 0)
2447     {
2448         double* currentUpperLeftPoint;
2449         double upperLeftPoint[3];
2450         int widthIndex = 2;
2451         int size = *numrow * *numcol;
2452
2453         if ( size != 5 && size != 4 )
2454         {
2455             Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),4,5,"z");
2456             return -1;
2457         }
2458
2459         upperLeftPoint[0] = tab[0];
2460         upperLeftPoint[1] = tab[1];
2461
2462         if ( size == 5 )
2463         {
2464             upperLeftPoint[2] = tab[2];
2465             widthIndex = 3;
2466         }
2467         else
2468         {
2469             /*
2470              * Needed in order to set the z coordinate if size == 4
2471              * Being able to set only the point's x and y coordinates values would avoid doing this.
2472              */
2473             getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
2474             upperLeftPoint[2] = currentUpperLeftPoint[2];
2475         }
2476
2477         setGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
2478
2479         /* check that the height and width are positive */
2480         if ( tab[widthIndex] < 0.0 || tab[widthIndex + 1] < 0.0 )
2481         {
2482             Scierror(999,"Width and height must be positive.\n") ;
2483             return -1 ;
2484         }
2485
2486         setGraphicObjectProperty(pthis, __GO_WIDTH__, &tab[widthIndex], jni_double, 1);
2487         setGraphicObjectProperty(pthis, __GO_HEIGHT__, &tab[widthIndex + 1], jni_double, 1);
2488
2489         return 0;
2490     }
2491     else if (strcmp(type, __GO_ARC__) == 0)
2492     {
2493         double startAngle;
2494         double endAngle;
2495         double upperLeftPoint[3];
2496         double width;
2497         double height;
2498         double* currentUpperLeftPoint;
2499         int size;
2500
2501         size = *numrow * *numcol;
2502
2503         if ((size != 7) && (size != 6))
2504         {
2505             Scierror(999, _("Number of elements must be %d (%d if z coordinate )\n"),6,7);
2506             return -1;
2507         }
2508
2509         upperLeftPoint[0] = tab[0];
2510         upperLeftPoint[1] = tab[1];
2511
2512         /*
2513          * Setting the data has been made consistent with how it is done for the Rectangle:
2514          * it takes into account the size of the input array instead of the parent Axes'
2515          * view property. Using the latter led to incorrectly set values when size and view
2516          * were not corresponding (for example when size==7, and view==2d).
2517          */
2518         if (size == 7)
2519         {
2520             upperLeftPoint[2] = tab[2];
2521             width = tab[3];
2522             height = tab[4];
2523             startAngle = DEG2RAD(tab[5]);
2524             endAngle = DEG2RAD(tab[6]);
2525         }
2526         else
2527         {
2528             /* Needed in order to set the z coordinate if size == 6 */
2529             getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
2530
2531             upperLeftPoint[2] = currentUpperLeftPoint[2];
2532             width = tab[2];
2533             height = tab[3];
2534             startAngle = DEG2RAD(tab[4]);
2535             endAngle = DEG2RAD(tab[5]);
2536         }
2537
2538         setGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
2539
2540         setGraphicObjectProperty(pthis, __GO_WIDTH__, &width, jni_double, 1);
2541         setGraphicObjectProperty(pthis, __GO_HEIGHT__, &height, jni_double, 1);
2542
2543         setGraphicObjectProperty(pthis, __GO_START_ANGLE__, &startAngle, jni_double, 1);
2544         setGraphicObjectProperty(pthis, __GO_END_ANGLE__, &endAngle, jni_double, 1);
2545
2546         return 0;
2547     }
2548     else if (strcmp(type, __GO_TEXT__) == 0)
2549     {
2550         char* parentAxes;
2551         double position[3];
2552         int iView = 0;
2553         int* piView = &iView;
2554
2555         if ((*numrow * *numcol != 2)&&(*numrow * *numcol != 3))
2556         {
2557             Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),2,3,"z");
2558             return -1;
2559         }
2560
2561         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
2562         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
2563
2564         position[0] = tab[0];
2565         position[1] = tab[1];
2566
2567         if (iView)
2568         {
2569             position[2] = tab[2];
2570         }
2571         else
2572         {
2573             /*
2574              * Required as the position has 3 coordinates, hence the z-coordinate
2575              * is set to its current value, which must be retrieved beforehand.
2576              * Avoiding doing this would require being able to set only the x and y
2577              * coordinates if required.
2578              */
2579             double* currentPosition;
2580             getGraphicObjectProperty(pthis, __GO_POSITION__, jni_double_vector, &currentPosition);
2581             position[2] = currentPosition[2];
2582         }
2583
2584         setGraphicObjectProperty(pthis, __GO_POSITION__, position, jni_double_vector, 3);
2585
2586         return 0;
2587     }
2588     else if (strcmp(type, __GO_SEGS__) == 0)
2589     {
2590         int numArrows;
2591         double* arrowPoints = NULL;
2592
2593         if ((*numcol != 3)&&(*numcol != 2))
2594         {
2595             Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
2596             return -1;
2597         }
2598
2599         if (*numrow % 2 != 0)
2600         {
2601             Scierror(999, _("Number of rows must be a multiple of 2.\n"));
2602             return -1;
2603         }
2604
2605
2606         numArrows = *numrow/2;
2607
2608         arrowPoints = (double*) MALLOC(3*numArrows*sizeof(double));
2609
2610         if (arrowPoints == NULL)
2611         {
2612             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2613             return -1;
2614         }
2615
2616         /*
2617          * Interlacing ought to be done in the MVC's coordinates
2618          * set function to avoid the additional code below.
2619          */
2620         for (i = 0; i < numArrows; i++)
2621         {
2622             arrowPoints[3*i] = tab[2*i];
2623             arrowPoints[3*i+1] = tab[2*numArrows+2*i];
2624
2625             if (*numcol == 3)
2626             {
2627                 arrowPoints[3*i+2] = tab[4*numArrows+2*i];
2628             }
2629             else
2630             {
2631                 arrowPoints[3*i+2] = 0.0;
2632             }
2633         }
2634
2635         setGraphicObjectProperty(pthis, __GO_NUMBER_ARROWS__, &numArrows, jni_int, 1);
2636
2637         setGraphicObjectProperty(pthis, __GO_BASE__, arrowPoints, jni_double_vector, 3*numArrows);
2638
2639         for (i = 0; i < numArrows; i++)
2640         {
2641             arrowPoints[3*i] = tab[2*i+1];
2642             arrowPoints[3*i+1] = tab[2*numArrows+2*i+1];
2643
2644             if (*numcol == 3)
2645             {
2646                 arrowPoints[3*i+2] = tab[4*numArrows+2*i+1];
2647             }
2648             else
2649             {
2650                 arrowPoints[3*i+2] = 0.0;
2651             }
2652         }
2653
2654         setGraphicObjectProperty(pthis, __GO_DIRECTION__, arrowPoints, jni_double_vector, 3*numArrows);
2655
2656         FREE(arrowPoints);
2657
2658         return 0;
2659     }
2660     /* DJ.A 2003 */
2661     /* SCI_SURFACE has been replaced by the MVC's FAC3D and PLOT3D */
2662     else if (strcmp(type, __GO_FAC3D__) == 0)
2663     {
2664         Scierror(999, _("Unhandled data field\n"));
2665         return -1;
2666     }
2667     else if (strcmp(type, __GO_PLOT3D__) == 0)
2668     {
2669         Scierror(999, _("Unhandled data field\n"));
2670         return -1;
2671     }
2672     else if (strcmp(type, __GO_MATPLOT__) == 0)
2673     {
2674         int nx;
2675         int ny;
2676         int gridSize[4];
2677         int result;
2678
2679         ny = *numrow;
2680         nx = *numcol;
2681
2682         /*
2683          * The number of points along each dimension is equal to the z data matrix's
2684          * corresponding dimension plus 1
2685          */
2686         gridSize[0] = nx + 1;
2687         gridSize[1] = 1;
2688         gridSize[2] = ny + 1;
2689         gridSize[3] = 1;
2690
2691         result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
2692
2693         if (result == FALSE)
2694         {
2695             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2696             return -1;
2697         }
2698
2699         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, tab, jni_double_vector, nx*ny);
2700     }
2701     else if (strcmp(type, __GO_FEC__) == 0)
2702     {
2703         BOOL result;
2704         int Nnode;
2705         if (*numcol != 3)
2706         {
2707             Scierror(999, _("Number of columns must be %d.\n"),3);
2708             return -1;
2709         }
2710
2711         Nnode = *numrow;
2712
2713         /* Resizes the data coordinates array if required */
2714         result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_VERTICES__, &Nnode, jni_int, 1);
2715
2716         if (result == FALSE)
2717         {
2718             Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
2719             return -1;
2720         }
2721
2722         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, tab, jni_double_vector, Nnode);
2723         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, &tab[Nnode], jni_double_vector, Nnode);
2724         setGraphicObjectProperty(pthis, __GO_DATA_MODEL_VALUES__, &tab[2*Nnode], jni_double_vector, Nnode);
2725     }
2726     else if (strcmp(type, __GO_FIGURE__) == 0)
2727     {
2728         printSetGetErrorMessage("data");
2729         return -1;
2730     }
2731     else if (strcmp(type, __GO_AXES__) == 0)
2732     {
2733         printSetGetErrorMessage("data");
2734         return -1;
2735     }
2736     else if (strcmp(type, __GO_LEGEND__) == 0)
2737     {
2738         printSetGetErrorMessage("data");
2739         return -1;
2740     }
2741     else if (strcmp(type, __GO_AXIS__) == 0)
2742     {
2743         printSetGetErrorMessage("data");
2744         return -1;
2745     }
2746     else if (strcmp(type, __GO_COMPOUND__) == 0)
2747     {
2748         printSetGetErrorMessage("data");
2749         return -1;
2750     }
2751     /* F.Leray 28.05.04 */
2752     else if (strcmp(type, __GO_LABEL__) == 0)
2753     {
2754         printSetGetErrorMessage("data");
2755         return -1;
2756     }
2757     /*
2758      * Deactivated for now
2759      * Same condition as the default one
2760      */
2761 #if 0
2762 case SCI_UIMENU:
2763 #endif
2764     else
2765     {
2766         printSetGetErrorMessage("data");
2767         return -1;
2768     }
2769
2770     return 0;
2771 }
2772
2773 int sciInitdrawmode( BOOL mode )
2774 {
2775 #if 0
2776     static sciPointObj * pobj ;
2777     pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
2778     pSUBWIN_FEATURE(pobj)->visible = mode ;
2779     sciDrawObj(sciGetCurrentFigure ());
2780 #endif
2781     return 0;
2782 }
2783
2784 int
2785 sciSetdrawmode (BOOL mode)
2786 {
2787 // ???
2788 #if 0
2789     static sciPointObj * pobj ;
2790     pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
2791     if ( sciGetdrawmode( pobj ) == mode )
2792     {
2793         /* nothing to do */
2794         return 1 ;
2795     }
2796     return sciInitdrawmode( mode ) ;
2797 #endif
2798     return 0;
2799 }
2800
2801 /*----------------------------------------------------------------------------------*/
2802 /**
2803  * In new graphic style, select a window and create one if not already done.
2804  */
2805 int sciSetUsedWindow( int winNum )
2806 {
2807     // FIXME
2808     abort();
2809 #if 0
2810         return 1;
2811     /* select or create the window in the driver */
2812     if ( sciHasFigures() && sciGetNum( sciGetCurrentFigure() ) == winNum )
2813     {
2814         /* nothing to do */
2815         return 1 ;
2816     }
2817
2818     return sciInitUsedWindow( winNum ) ;
2819 #endif
2820     return 1;
2821 }
2822
2823 /*----------------------------------------------------------------------------------*/
2824
2825
2826
2827 int sciInitIsFilled( char * pobjUID, BOOL isfilled )
2828 {
2829     // FIXME
2830     abort();
2831 #if 0
2832         switch (sciGetEntityType (pobjUID))
2833     {
2834     case SCI_LABEL:
2835         /* isfilled correspond to several properties in text object */
2836         sciInitIsBoxed(  pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
2837         sciInitIsLine(   pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
2838         return sciInitIsFilled( pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
2839     case SCI_SUBWIN:
2840         pSUBWIN_FEATURE(pobjUID)->axes.filled = isfilled;
2841         return 0;
2842     default:
2843         if(sciGetGraphicContext(pobjUID) != NULL)
2844         {
2845             sciGetGraphicContext(pobjUID)->isfilled = isfilled;
2846             return 0;
2847         }
2848     }
2849
2850     printSetGetErrorMessage("fill_mode");
2851 #endif
2852     return -1;
2853 }
2854
2855 /**sciSetIsFilled
2856  * Sets the filled line existence
2857  */
2858 int
2859 sciSetIsFilled (char * pobjUID, BOOL isfilled)
2860 {
2861
2862     if ( sciGetIsFilled( pobjUID ) == isfilled )
2863     {
2864         return 1 ;
2865     }
2866     return sciInitIsFilled( pobjUID, isfilled ) ;
2867
2868 }
2869
2870
2871 int sciInitBoxType( char * pobjUID, EAxesBoxType type )
2872 {
2873     // FIXME
2874     abort();
2875 #if 0
2876         switch (sciGetEntityType (pobjUID))
2877     {
2878     case SCI_SUBWIN:
2879         pSUBWIN_FEATURE(pobjUID)->axes.rect = type ;
2880         /* redondant information in scilab :'( */
2881         switch ( type )
2882         {
2883         case BT_OFF:
2884             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 0 ;
2885             break ;
2886         case BT_ON:
2887             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 4 ;
2888             break ;
2889         case BT_HIDDEN_AXES:
2890             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 2 ;
2891             break ;
2892         case BT_BACK_HALF:
2893             pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 3 ;
2894             break ;
2895         }
2896         return 0;
2897         break;
2898     default:
2899         printSetGetErrorMessage("box_type");
2900         return -1 ;
2901         break;
2902     }
2903 #endif
2904         return -1 ;
2905 }
2906
2907 /* set the property of the axes box  */
2908 int sciSetBoxType( char * pobjUID, EAxesBoxType type )
2909 {
2910
2911     if ( sciGetBoxType( pobjUID ) == type )
2912     {
2913         return 1 ;
2914     }
2915     return sciInitBoxType( pobjUID, type ) ;
2916
2917 }
2918
2919
2920 int sciInitIsBoxed( char * pobjUID, BOOL isboxed )
2921 {
2922     // FIXME
2923     abort();
2924 #if 0
2925         switch (sciGetEntityType (pobjUID))
2926     {
2927     case SCI_TEXT:
2928         pTEXT_FEATURE(pobjUID)->isboxed = isboxed;
2929         return 0;
2930         break;
2931     case SCI_SUBWIN:
2932         Scierror(999, _("%s: please use %s instead.\n"),"sciSetIsBoxed","sciSetBoxType");
2933         if ( isboxed )
2934         {
2935             pSUBWIN_FEATURE(pobjUID)->axes.rect = BT_ON ;
2936         }
2937         else
2938         {
2939             pSUBWIN_FEATURE(pobjUID)->axes.rect = BT_OFF ;
2940         }
2941         return 0;
2942         break;
2943     case SCI_LABEL:
2944     case SCI_POLYLINE:
2945     case SCI_RECTANGLE:
2946     case SCI_ARC:
2947     case SCI_FIGURE:
2948     case SCI_SURFACE:
2949     case SCI_AXES:
2950     case SCI_LEGEND:
2951     case SCI_SEGS:
2952     case SCI_FEC:
2953     case SCI_GRAYPLOT:
2954     case SCI_AGREG:
2955     case SCI_UIMENU:
2956     default:
2957         printSetGetErrorMessage("box_type");
2958         return -1;
2959         break;
2960     }
2961 #endif
2962         return -1 ;
2963 }
2964
2965 /**sciSetIsBoxed
2966  * Sets the box existence
2967  */
2968 int
2969 sciSetIsBoxed (char * pobjUID, BOOL isboxed)
2970 {
2971
2972     if ( sciGetIsBoxed( pobjUID ) == isboxed )
2973     {
2974         return 1 ;
2975     }
2976     return sciInitIsBoxed( pobjUID, isboxed ) ;
2977
2978 }
2979
2980
2981 int
2982 sciInitNbXSubTics(char * pobjUID, int nbsubtics)
2983 {
2984     // FIXME
2985     abort();
2986 #if 0
2987         switch (sciGetEntityType (pobjUID))
2988     {
2989     case SCI_SUBWIN:
2990         pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[0] = nbsubtics;
2991         break;
2992     default:
2993         printSetGetErrorMessage("subwin_type required");
2994         return -1 ;
2995         break;
2996     }
2997 #endif
2998     return 0 ;
2999 }
3000
3001 /**sciSetNbXSubTics
3002  * Sets the number of x subticks
3003  */
3004 int
3005 sciSetNbXSubTics(char * pobjUID, int nbsubtics)
3006 {
3007     int curr_nbsubtics[3];
3008
3009     sciGetNbSubTics( pobjUID,  curr_nbsubtics);
3010
3011     if ( curr_nbsubtics[0] == nbsubtics )
3012     {
3013         return 1 ;
3014     }
3015     return sciInitNbXSubTics( pobjUID, nbsubtics ) ;
3016 }
3017
3018 int
3019 sciInitNbYSubTics(char * pobjUID, int nbsubtics)
3020 {
3021 // FIXME
3022     abort();
3023 #if 0
3024     switch (sciGetEntityType (pobjUID))
3025     {
3026     case SCI_SUBWIN:
3027         pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[1] = nbsubtics;
3028         break;
3029     default:
3030         printSetGetErrorMessage("subwin_type required");
3031         return -1 ;
3032         break;
3033     }
3034 #endif
3035     return 0 ;
3036 }
3037
3038 /**sciSetNbYSubTics
3039  * Sets the number of y subticks
3040  */
3041 int
3042 sciSetNbYSubTics(char * pobjUID, int nbsubtics)
3043 {
3044     int curr_nbsubtics[3];
3045
3046     sciGetNbSubTics( pobjUID,  curr_nbsubtics);
3047
3048     if ( curr_nbsubtics[1] == nbsubtics )
3049     {
3050         return 1 ;
3051     }
3052     return sciInitNbYSubTics( pobjUID, nbsubtics ) ;
3053 }
3054
3055 int
3056 sciInitNbZSubTics(char * pobjUID, int nbsubtics)
3057 {
3058     // FIXME
3059     abort();
3060 #if 0
3061         switch (sciGetEntityType (pobjUID))
3062     {
3063     case SCI_SUBWIN:
3064         pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[2] = nbsubtics;
3065         break;
3066     default:
3067         printSetGetErrorMessage("subwin_type required");
3068         return -1 ;
3069         break;
3070     }
3071 #endif
3072     return 0 ;
3073 }
3074
3075 /**sciSetNbZSubTics
3076  * Sets the number of x subticks
3077  */
3078 int
3079 sciSetNbZSubTics(char * pobjUID, int nbsubtics)
3080 {
3081     int curr_nbsubtics[3];
3082
3083     sciGetNbSubTics( pobjUID,  curr_nbsubtics);
3084
3085     if ( curr_nbsubtics[2] == nbsubtics )
3086     {
3087         return 1 ;
3088     }
3089     return sciInitNbZSubTics( pobjUID, nbsubtics ) ;
3090 }
3091
3092
3093 int
3094 sciSetInterpVector(char * pobjUID, int size, int * value)
3095 {
3096     // FIXME
3097     abort();
3098 #if 0
3099         int i;
3100
3101     FREE(pPOLYLINE_FEATURE(pobjUID)->scvector);
3102
3103     if((pPOLYLINE_FEATURE(pobjUID)->scvector = MALLOC(size*sizeof(int)))==NULL){
3104         Scierror(999, _("%s: No more memory.\n"), "sciSetInterpVector") ;
3105         return -1;
3106     }
3107
3108     for(i=0;i<size;i++)
3109         pPOLYLINE_FEATURE(pobjUID)->scvector[i] = value[i];
3110 #endif
3111     return 0;
3112 }
3113
3114 int sciInitAutoRotation( char * pobjUID, BOOL value )
3115 {
3116     // FIXME
3117     abort();
3118 #if 0
3119         switch (sciGetEntityType (pobjUID))
3120     {
3121     case SCI_LABEL:
3122         pLABEL_FEATURE(pobjUID)->auto_rotation = value ;
3123         return 0;
3124     case SCI_POLYLINE:
3125     case SCI_RECTANGLE:
3126     case SCI_ARC:
3127     case SCI_TEXT:
3128     case SCI_FIGURE:
3129     case SCI_SUBWIN:
3130     case SCI_SURFACE:
3131     case SCI_AXES:
3132     case SCI_FEC:
3133     case SCI_SEGS:
3134     case SCI_LEGEND:
3135     case SCI_GRAYPLOT:
3136     case SCI_AGREG:
3137     case SCI_UIMENU:
3138     default:
3139         printSetGetErrorMessage("auto_rotation");
3140         return -1 ;
3141         break;
3142     }
3143 #endif
3144         return -1;
3145
3146 }
3147
3148 /* set the auto_rotation property of an object */
3149 int sciSetAutoRotation ( char * pobjUID, BOOL value )
3150 {
3151
3152     if ( sciGetAutoRotation( pobjUID ) == value )
3153     {
3154         /* nothing to do */
3155         return 1 ;
3156     }
3157     return sciInitAutoRotation( pobjUID, value ) ;
3158
3159 }
3160
3161
3162 int sciInitAutoPosition( char * pobjUID, BOOL value )
3163 {
3164     // FIXME
3165     abort();
3166 #if 0
3167         switch (sciGetEntityType (pobjUID))
3168     {
3169     case SCI_LABEL:
3170         pLABEL_FEATURE(pobjUID)->auto_position = value ;
3171         return 0;
3172     case SCI_POLYLINE:
3173     case SCI_RECTANGLE:
3174     case SCI_ARC:
3175     case SCI_TEXT:
3176     case SCI_FIGURE:
3177     case SCI_SUBWIN:
3178     case SCI_SURFACE:
3179     case SCI_AXES:
3180     case SCI_FEC:
3181     case SCI_SEGS:
3182     case SCI_LEGEND:
3183     case SCI_GRAYPLOT:
3184     case SCI_AGREG:
3185     case SCI_UIMENU:
3186     default:
3187         printSetGetErrorMessage("auto_position");
3188         return -1 ;
3189         break;
3190     }
3191 #endif
3192
3193 }
3194
3195 /* set the auto_position property of an object */
3196 int sciSetAutoPosition ( char * pobjUID, BOOL value )
3197 {
3198
3199     if ( sciGetAutoPosition( pobjUID ) == value )
3200     {
3201         /* nothing to do */
3202         return 1 ;
3203     }
3204     return sciInitAutoPosition( pobjUID, value ) ;
3205
3206 }
3207
3208 /*---------------------------------------------------------------------------*/
3209 int checkPercent( char * string )
3210 {
3211     /* check for the percent in the string */
3212     char * firstPercent  = strchr( string, '%' ) ;
3213
3214     if ( firstPercent == NULL )
3215     {
3216         /* no % character found */
3217         return 0 ;
3218     }
3219     else if ( firstPercent[1] != 'd' )
3220     {
3221         /* a %something with something != d has been found */
3222         return -1 ;
3223     }
3224     else
3225     {
3226         /* here we have found a first %d, check if there is not any more % */
3227         firstPercent++ ;
3228         firstPercent = strchr( firstPercent, '%' ) ;
3229         if ( firstPercent == NULL )
3230         {
3231             /* no other % character found */
3232             return 1 ;
3233         }
3234         else
3235         {
3236             return -1 ;
3237         }
3238     }
3239 }
3240 /*---------------------------------------------------------------------------*/
3241 int sciInitAutoSize( char * pobjUID, BOOL autoSize )
3242 {
3243 // FIXME
3244 #if 0
3245     switch ( sciGetEntityType (pobjUID) )
3246     {
3247     case SCI_TEXT:
3248         pTEXT_FEATURE(pobjUID)->autoSize = autoSize ;
3249         return 0 ;
3250     default:
3251         printSetGetErrorMessage("text_box_mode");
3252         return -1 ;
3253         break;
3254     }
3255 #endif
3256     return -1;
3257
3258 }
3259 /*---------------------------------------------------------------------------*/
3260 int sciSetAutoSize( char * pobjUID, BOOL autoSize )
3261 {
3262     if ( sciGetAutoSize( pobjUID ) == autoSize )
3263     {
3264         /* nothing to do */
3265         return 1 ;
3266     }
3267     return sciInitAutoSize( pobjUID, autoSize ) ;
3268 }
3269 /*-----------------------------------------------------------------------------------*/
3270 int sciInitAlignment( char * pobjUID, sciTextAlignment align )
3271 {
3272     // FIXME
3273     abort();
3274 #if 0
3275         switch (sciGetEntityType (pobjUID))
3276     {
3277     case SCI_TEXT:
3278         pTEXT_FEATURE(pobjUID)->stringsAlign = align ;
3279         return 0 ;
3280     default:
3281         printSetGetErrorMessage("alignment");
3282         return -1 ;
3283     }
3284 #endif
3285
3286 }
3287 /*-----------------------------------------------------------------------------------*/
3288 int sciSetAlignment( char * pobjUID, sciTextAlignment align )
3289 {
3290     if ( sciGetAlignment( pobjUID ) == align )
3291     {
3292         /* nothing to do */
3293         return 1 ;
3294     }
3295     return sciInitAlignment( pobjUID, align ) ;
3296 }
3297 /*-----------------------------------------------------------------------------------*/
3298 int sciInitUserSize( char * pobjUID, double width, double height )
3299 {
3300     // FIXME
3301     abort();
3302 #if 0
3303         switch( sciGetEntityType( pobjUID ) )
3304     {
3305     case SCI_TEXT:
3306         pTEXT_FEATURE(pobjUID)->userSize[0] = width ;
3307         pTEXT_FEATURE(pobjUID)->userSize[1] = height ;
3308         return 0 ;
3309     default:
3310         printSetGetErrorMessage("text_box");
3311         return -1 ;
3312     }
3313 #endif
3314         return -1;
3315 }
3316 /*-----------------------------------------------------------------------------------*/
3317 int sciSetUserSize( char * pobjUID, double width, double height )
3318 {
3319     double curWidth  ;
3320     double curHeight ;
3321     sciGetUserSize( pobjUID, &curWidth, &curHeight ) ;
3322     if ( curWidth == width && curHeight == height )
3323     {
3324         /* nothing to do */
3325         return 1 ;
3326     }
3327     return sciInitUserSize( pobjUID, width, height ) ;
3328 }
3329 /*-----------------------------------------------------------------------------------*/
3330 int sciInitCenterPos( char * pobjUID, BOOL newCP )
3331 {
3332     // FIXME
3333     abort();
3334 #if 0
3335         switch( sciGetEntityType( pobjUID ) )
3336     {
3337     case SCI_TEXT:
3338         pTEXT_FEATURE(pobjUID)->centeredPos = newCP ;
3339         return 0 ;
3340     default:
3341         printSetGetErrorMessage("data");
3342         return -1 ;
3343     }
3344 #endif
3345         return -1;
3346
3347 }
3348 /*-----------------------------------------------------------------------------------*/
3349 int sciSetCenterPos( char * pobjUID, BOOL newCP )
3350 {
3351     if ( sciGetCenterPos( pobjUID ) == newCP )
3352     {
3353         /* nothing to do */
3354         return 1 ;
3355     }
3356     return sciInitCenterPos( pobjUID, newCP ) ;
3357 }
3358 /*-----------------------------------------------------------------------------------*/
3359 int sciInitIs3d(  char * pobjUID, BOOL is3d )
3360 {
3361     // FIXME
3362     abort();
3363 #if 0
3364         switch( sciGetEntityType( pobjUID ) )
3365     {
3366     case SCI_SUBWIN:
3367         if ( is3d )
3368         {
3369             pSUBWIN_FEATURE (pobjUID)->is3d = TRUE ;
3370             Obj_RedrawNewAngle( pobjUID,
3371                                 pSUBWIN_FEATURE (pobjUID)->alpha_kp,
3372                                 pSUBWIN_FEATURE (pobjUID)->theta_kp ) ;
3373         }
3374         else
3375         {
3376             /* switch to 2d */
3377             if ( sciGetSurface(pobjUID) == NULL)
3378             {
3379                 pSUBWIN_FEATURE (pobjUID)->is3d = FALSE;
3380                 pSUBWIN_FEATURE (pobjUID)->project[2]= 0;
3381             }
3382             pSUBWIN_FEATURE (pobjUID)->theta_kp = pSUBWIN_FEATURE (pobjUID)->theta;
3383             pSUBWIN_FEATURE (pobjUID)->alpha_kp = pSUBWIN_FEATURE (pobjUID)->alpha;
3384             pSUBWIN_FEATURE (pobjUID)->alpha = 0.0;
3385             pSUBWIN_FEATURE (pobjUID)->theta = 270.0;
3386             pSUBWIN_FEATURE(pobjUID)->is3d = FALSE;
3387             return 0 ;
3388         }
3389         return 0 ;
3390     case SCI_TEXT:
3391         pTEXT_FEATURE( pobjUID )->is3d = is3d ;
3392         return 0 ;
3393     case SCI_LABEL:
3394         return sciInitIs3d( pLABEL_FEATURE( pobjUID )->text, is3d ) ;
3395     default:
3396         printSetGetErrorMessage("view");
3397         return -1 ;
3398     }
3399 #endif
3400         return -1;
3401 }
3402 /*-----------------------------------------------------------------------------------*/
3403 /**
3404  * Force an object to be displayed in 2d or 3d mode.
3405  */
3406 int sciSetIs3d( char * pobjUID, BOOL is3d )
3407 {
3408     if ( sciGetIs3d( pobjUID ) == is3d )
3409     {
3410         /* nothing to do */
3411         return 1 ;
3412     }
3413     return sciInitIs3d( pobjUID, is3d ) ;
3414 }
3415 /*-----------------------------------------------------------------------------------*/
3416 int sciInitHiddenColor( char * pobjUID, int newColor )
3417 {
3418     // FIXME
3419     abort();
3420 #if 0
3421         if(!sciCheckColorIndex(pobjUID, newColor)) { return -1;}
3422
3423     switch( sciGetEntityType( pobjUID ) )
3424     {
3425     case SCI_SUBWIN:
3426         pSUBWIN_FEATURE(pobjUID)->hiddencolor = newColor;
3427         return 0 ;
3428     case SCI_SURFACE:
3429         pSURFACE_FEATURE(pobjUID)->hiddencolor = newColor;
3430         return 0;
3431     default:
3432         printSetGetErrorMessage("hidden_color");
3433         return -1 ;
3434     }
3435 #endif
3436     return -1;
3437 }
3438 /*-----------------------------------------------------------------------------------*/
3439 int sciSetHiddenColor( char * pobjUID, int newColor )
3440 {
3441     if ( sciGetHiddenColor( pobjUID ) == newColor )
3442     {
3443         /* nothing to do */
3444         return 1 ;
3445     }
3446     return sciInitHiddenColor( pobjUID, newColor ) ;
3447 }
3448 /*-----------------------------------------------------------------------------------*/
3449 int sciInitHiddenAxisColor( char * pobjUID, int newColor )
3450 {
3451     // FIXME
3452     abort();
3453 #if 0
3454         int m = sciGetNumColors(pobjUID);
3455     if(newColor < -2 || newColor > m + 2) return 0;
3456
3457     newColor = sciSetGoodIndex(pobjUID,newColor);
3458
3459     switch( sciGetEntityType( pobjUID ) )
3460     {
3461     case SCI_SUBWIN:
3462         pSUBWIN_FEATURE(pobjUID)->axes.hiddenAxisColor = Max (0, Min (newColor - 1, m + 1));
3463         return 0 ;
3464     default:
3465         printSetGetErrorMessage("hidden_axis_color");
3466         return -1 ;
3467     }
3468 #endif
3469     return -1;
3470 }
3471 /*-----------------------------------------------------------------------------------*/
3472 int sciSetHiddenAxisColor( char * pobjUID, int newColor )
3473 {
3474     if ( sciGetHiddenAxisColor( pobjUID ) == newColor )
3475     {
3476         /* nothing to do */
3477         return 1 ;
3478     }
3479     return sciInitHiddenAxisColor( pobjUID, newColor ) ;
3480 }
3481 /*-----------------------------------------------------------------------------------*/
3482 int sciInitGridStyle( char * pobjUID, int xStyle, int yStyle, int zStyle )
3483 {
3484     // FIXME
3485     abort();
3486 #if 0
3487         if (    !sciCheckColorIndex(pobjUID, xStyle)
3488             || !sciCheckColorIndex(pobjUID, yStyle)
3489             || !sciCheckColorIndex(pobjUID, zStyle))
3490     {
3491         return -1;
3492     }
3493
3494     switch( sciGetEntityType( pobjUID ) )
3495     {
3496     case SCI_SUBWIN:
3497         pSUBWIN_FEATURE(pobjUID)->grid[0] = xStyle ;
3498         pSUBWIN_FEATURE(pobjUID)->grid[1] = yStyle ;
3499         pSUBWIN_FEATURE(pobjUID)->grid[2] = zStyle ;
3500         return 0 ;
3501     default:
3502         printSetGetErrorMessage("grid");
3503         return -1 ;
3504     }
3505 #endif
3506     return -1;
3507 }
3508 /*-----------------------------------------------------------------------------------*/
3509 /**
3510  * Set the grid of an axes object
3511  */
3512 int sciSetGridStyle( char * pobjUID, int xStyle, int yStyle, int zStyle )
3513 {
3514     int curX ;
3515     int curY ;
3516     int curZ ;
3517     sciGetGridStyle( pobjUID, &curX, &curY, &curZ ) ;
3518     if ( curX == xStyle && curY == yStyle && curZ == zStyle )
3519     {
3520         /* nothing to do */
3521         return 1 ;
3522     }
3523     return sciInitGridStyle( pobjUID, xStyle, yStyle, zStyle ) ;
3524 }
3525 /*-----------------------------------------------------------------------------------*/
3526 /**
3527  * Set the viewport property of a figure.
3528  * Effective only if the auto_resize property is enable
3529  */
3530 int sciSetViewport( char * pobjUID, const int viewport[4] )
3531 {
3532     // FIXME
3533     abort();
3534 #if 0
3535         switch( sciGetEntityType( pobjUID ) )
3536     {
3537     case SCI_FIGURE:
3538         if (isFigureModel(pobjUID))
3539         {
3540             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[0] = viewport[0];
3541             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[1] = viewport[1];
3542             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[2] = viewport[2];
3543             pFIGURE_FEATURE(pobjUID)->pModelData->viewport[3] = viewport[3];
3544         }
3545         else
3546         {
3547             sciSetJavaViewport(pobjUID, viewport);
3548         }
3549         return 0;
3550     default:
3551         printSetGetErrorMessage("viewport");
3552         return -1 ;
3553     }
3554 #endif
3555         return -1;
3556 }
3557 /*-----------------------------------------------------------------------------------*/
3558 int sciInitInfoMessage(char * pobjUID, const char * newMessage)
3559 {
3560     // FIXME
3561     abort();
3562 #if 0
3563         if ( sciGetEntityType( pobjUID ) == SCI_FIGURE)
3564         {
3565
3566                 /* first case newName is NULL */
3567                 if (newMessage == NULL)
3568                 {
3569                         /* Just set an empty title for the physical window if needed */
3570                         if(isFigureModel(pobjUID))
3571                         {
3572                                 pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = NULL;
3573                         }
3574                         else
3575                         {
3576                                 sciSetJavaInfoMessage(pobjUID, "");
3577                         }
3578
3579                         return 0;
3580                 }
3581
3582                 if (isFigureModel(pobjUID))
3583                 {
3584                         /* Copy the message into the special data */
3585                         int newMessageLength = (int) strlen(newMessage);
3586                         pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = MALLOC((newMessageLength + 1) * sizeof(char));
3587                         if (pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage != NULL)
3588                         {
3589                                 strcpy(pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage, newMessage);
3590                         }
3591                 }
3592                 else
3593                 {
3594                         /* Copy in the Java data */
3595                         sciSetJavaInfoMessage(pobjUID, newMessage);
3596                 }
3597
3598                 return 0 ;
3599         }
3600         else
3601         {
3602                 printSetGetErrorMessage("info_message");
3603                 return -1;
3604         }
3605 #endif
3606         return -1;
3607 }
3608 /*-----------------------------------------------------------------------------------*/
3609 /**
3610  * Modify the string in the info bar of the graphic window
3611  */
3612 int sciSetInfoMessage( char * pobjUID, const char * newMessage )
3613 {
3614     // FIXME
3615     abort();
3616 #if 0
3617         if (isFigureModel(pobjUID) && pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage != NULL)
3618         {
3619                 FREE(pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage);
3620                 pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = NULL;
3621         }
3622         return sciInitInfoMessage(pobjUID, newMessage);
3623 #endif
3624     return -1;
3625 }
3626 /*-----------------------------------------------------------------------------------*/
3627 int sciInitEventHandler( char * pobjUID, char * name )
3628 {
3629     // FIXME
3630     abort();
3631 #if 0
3632         if( sciGetEntityType( pobjUID ) == SCI_FIGURE)
3633     {
3634         sciFigure * ppFigure = pFIGURE_FEATURE(pobjUID) ;
3635
3636         if ( ppFigure == NULL )
3637         {
3638             Scierror(999, _("%s: No more memory.\n"), "sciInitEventHandler") ;
3639             return -1 ;
3640         }
3641
3642         if ( ppFigure->eventHandler != NULL )
3643         {
3644             FREE(ppFigure->eventHandler);
3645         }
3646
3647         ppFigure->eventHandler = strdup(name);
3648
3649         /* Java is called to set the listener */
3650         if (!isFigureModel(pobjUID))
3651         {
3652             setFigureEventHandler(sciGetNum(pobjUID), name);
3653         }
3654
3655         if ( strcmp( name, "" ) == 0 )
3656         {
3657             sciInitIsEventHandlerEnable( pobjUID, FALSE ) ;
3658         }
3659
3660         return 0 ;
3661     }
3662     else
3663     {
3664         printSetGetErrorMessage("event_handler");
3665         return -1 ;
3666     }
3667 #endif
3668         return -1;
3669 }
3670 /*-----------------------------------------------------------------------------------*/
3671 int sciSetEventHandler( char * pobjUID, char * name )
3672 {
3673     if ( strcmp( sciGetEventHandler(pobjUID), name ) == 0 )
3674     {
3675         /* nothing to do */
3676         return 1 ;
3677     }
3678
3679     return sciInitEventHandler( pobjUID, name ) ;
3680 }
3681 /*-----------------------------------------------------------------------------------*/
3682 int sciInitIsEventHandlerEnable( char * pobjUID, BOOL enable )
3683 {
3684     // FIXME
3685     abort();
3686 #if 0
3687         if(sciGetEntityType( pobjUID ) == SCI_FIGURE)
3688     {
3689         sciFigure * ppFigure = pFIGURE_FEATURE(pobjUID) ;
3690         /*
3691         ** If we try to enable an empty Event Handler
3692         ** raise a Warning.
3693         */
3694         if (ppFigure != NULL
3695             && ppFigure->eventHandler != NULL
3696             && (strcmp(ppFigure->eventHandler, "") != 0 || enable == FALSE))
3697         {
3698             pFIGURE_FEATURE(pobjUID)->isEventHandlerEnable = enable ;
3699
3700             /* Java is called to enable or disable the listener */
3701             if (!isFigureModel(pobjUID))
3702             {
3703                 setFigureEventHandlerEnabled(sciGetNum(pobjUID), enable);
3704             }
3705         }
3706         else
3707         {
3708             Scierror(999, _("%s: Can't enable a void event handler.\n"), "sciInitEventHandler") ;
3709         }
3710         return 0 ;
3711     }
3712     else
3713     {
3714         printSetGetErrorMessage("event_handler");
3715         return -1 ;
3716     }
3717 #endif
3718         return -1;
3719 }
3720 /*-----------------------------------------------------------------------------------*/
3721 int sciSetIsEventHandlerEnable( char * pobjUID, BOOL enable )
3722 {
3723     if ( sciGetIsEventHandlerEnable(pobjUID) == enable )
3724     {
3725         /* nothing to do */
3726         return 1 ;
3727     }
3728
3729     return sciInitIsEventHandlerEnable( pobjUID, enable ) ;
3730 }
3731 /*-----------------------------------------------------------------------------------*/
3732 /**
3733  * Set data-bounds defined by the user.
3734  * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
3735  */
3736 int sciSetDataBounds( char * pobjUID, double bounds[6] )
3737 {
3738     // FIXME
3739     abort();
3740 #if 0
3741         int i;
3742     switch( sciGetEntityType(pobjUID) )
3743     {
3744     case SCI_SUBWIN:
3745         for ( i = 0 ; i < 6 ; i++ )
3746         {
3747             pSUBWIN_FEATURE(pobjUID)->SRect[i] = bounds[i] ;
3748         }
3749         return 0;
3750     case SCI_SURFACE:
3751         for ( i = 0 ; i < 6 ; i++ )
3752         {
3753             pSURFACE_FEATURE(pobjUID)->ebox[i] = bounds[i] ;
3754         }
3755         return 0;
3756     default:
3757         printSetGetErrorMessage("data_bounds");
3758         return -1 ;
3759
3760     }
3761 #endif
3762     return -1;
3763 }
3764 /*-----------------------------------------------------------------------------------*/
3765 /**
3766  * Set the displayed data bounds of a subwin object.
3767  */
3768 int sciSetRealDataBounds(char * pobjUID, const double bounds[6])
3769 {
3770      // FIXME
3771     abort();
3772 #if 0
3773        int i;
3774     switch( sciGetEntityType(pobjUID) )
3775     {
3776     case SCI_SUBWIN:
3777         for ( i = 0 ; i < 6 ; i++ )
3778         {
3779             pSUBWIN_FEATURE(pobjUID)->FRect[i] = bounds[i] ;
3780         }
3781         return 0;
3782     default:
3783         printSetGetErrorMessage("data_bounds");
3784         return -1 ;
3785
3786     }
3787 #endif
3788     return -1;
3789 }
3790 /*--------------------------------------------------------------------------------------------*/
3791 int sciInitViewingAngles( char * pobjUID, double alpha, double theta)
3792 {
3793      // FIXME
3794     abort();
3795 #if 0
3796        switch(sciGetEntityType(pobjUID))
3797     {
3798     case SCI_SUBWIN:
3799         pSUBWIN_FEATURE(pobjUID)->alpha = alpha;
3800         pSUBWIN_FEATURE(pobjUID)->theta = theta;
3801         return 0;
3802     default:
3803         printSetGetErrorMessage("rotation_angles");
3804         return -1;
3805     }
3806 #endif
3807        return -1;
3808 }
3809 /*-----------------------------------------------------------------------------------*/
3810 /**
3811  * Set the viewing angles (in degrees) of a subwindow
3812  */
3813 int sciSetViewingAngles( char * pobjUID, double alpha, double theta)
3814 {
3815     double curAlpha;
3816     double curTheta;
3817     sciGetViewingAngles(pobjUID, &curAlpha, &curTheta);
3818     if ( curAlpha == alpha && curTheta == theta )
3819     {
3820         /* nothing to do */
3821         return 1;
3822     }
3823
3824     return sciInitViewingAngles(pobjUID, alpha, theta) ;
3825
3826 }
3827 /*-----------------------------------------------------------------------------------*/
3828 /**
3829  * Set the info message of a figure with the information about rotation angles
3830  */
3831 int setInfoMessageWithRotationAngles(char * pFigure, double alpha, double theta)
3832 {
3833     // FIXME
3834     abort();
3835 #if 0
3836         /* keep this lower than 10*/
3837 #define ANGLE_DECIMAL_NUMBERS 1
3838     char angleDisplayFormat[5];
3839     int returnStatus = -1;
3840     double intPart;
3841     char * infoMessage = NULL;
3842     char formatedInfoMessage[29];
3843
3844     /* Size without numbers is 8 for "alpha = ", 10 for ", theta = " and 1 for the null terminating character */
3845     int infoMessageSize = 19;
3846
3847     /* set number of digits so format is %.xf where x is ANGLE_DECIMAL_NUMBERS */
3848     sprintf(angleDisplayFormat, "%%.%df", ANGLE_DECIMAL_NUMBERS);
3849
3850     /* compute size of alpha wich is the length of its int part plus 1 for the dot */
3851     /* and the number of decimals */
3852     modf(alpha, &intPart); /* get int part of alpha */
3853     infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
3854
3855     /* same for theta */
3856     modf(theta, &intPart);
3857     infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
3858
3859     /* We use also infomessage string to store the formated massage */
3860     /* The needed size might be 19 plus twice the format length so 8 => 27 */
3861
3862     /* Add alpha size, which is the size of its int part plus 1 for the dot and only  */
3863
3864     infoMessage = MALLOC(infoMessageSize * sizeof(char));
3865     if (infoMessage == NULL)
3866     {
3867         /* no more memory */
3868         return -1;
3869     }
3870
3871     /* Put the formats in the string */
3872     sprintf(formatedInfoMessage, "alpha = %s, theta = %s", angleDisplayFormat, angleDisplayFormat);
3873
3874     /* convert the formats into the angle values */
3875     sprintf(infoMessage, formatedInfoMessage, alpha, theta);
3876
3877     returnStatus = sciSetInfoMessage(pFigure, infoMessage) ;
3878
3879     FREE(infoMessage);
3880
3881     return returnStatus;
3882
3883 #undef ANGLE_DECIMAL_NUMBERS
3884 #endif
3885     return -1;
3886 }
3887 /*-----------------------------------------------------------------------------------*/
3888 /**
3889  * To set the pixmap mode of a figure to on or off
3890  */
3891 int sciInitPixmapMode(char * pobjUID, BOOL onOrOff)
3892 {
3893      // FIXME
3894     abort();
3895 #if 0
3896        switch(sciGetEntityType(pobjUID))
3897     {
3898     case SCI_FIGURE:
3899         pFIGURE_FEATURE(pobjUID)->pixmapMode = onOrOff;
3900         return 0;
3901     default:
3902         printSetGetErrorMessage("pixmap");
3903         return -1;
3904     }
3905 #endif
3906        return -1;
3907 }
3908 /*----------------------------------------------------------------------------------*/
3909 /**
3910  * To set the pixmap mode of a figure to on or off
3911  */
3912 int sciSetPixmapMode(char * pobjUID, BOOL onOrOff)
3913 {
3914     if (sciGetPixmapMode(pobjUID) == onOrOff)
3915     {
3916         /* Nothing to do */
3917         return 1;
3918     }
3919     return sciInitPixmapMode(pobjUID, onOrOff);
3920 }
3921 /*----------------------------------------------------------------------------------*/
3922 int sciInitTextPos( char * pobjUID, double posX, double posY, double posZ)
3923 {
3924     // FIXME
3925     abort();
3926 #if 0
3927         switch(sciGetEntityType(pobjUID))
3928     {
3929     case SCI_TEXT:
3930         pTEXT_FEATURE(pobjUID)->x = posX;
3931         pTEXT_FEATURE(pobjUID)->y = posY;
3932         pTEXT_FEATURE(pobjUID)->z = posZ;
3933         return 0;
3934     case SCI_LABEL:
3935         return sciInitTextPos(pLABEL_FEATURE(pobjUID)->text, posX, posY, posZ);
3936     default:
3937         printSetGetErrorMessage("data");
3938         return -1;
3939     }
3940 #endif
3941         return -1;
3942 }
3943 /*----------------------------------------------------------------------------------*/
3944 /**
3945  * Set the position of a label or text object.
3946  */
3947 int sciSetTextPos( char * pobjUID, double posX, double posY, double posZ)
3948 {
3949     double curPos[3];
3950     sciGetTextPos(pobjUID, curPos);
3951     if ( curPos[0] == posX && curPos[1] == posY && curPos[2] == posZ )
3952     {
3953         /* nothing to do */
3954         return 1;
3955     }
3956     return sciInitTextPos(pobjUID, posX, posY, posZ);
3957 }
3958 /*----------------------------------------------------------------------------------*/
3959 int sciInitLogFlags(char * pobjUID, char logFlags[3])
3960 {
3961     // FIXME
3962     abort();
3963 #if 0
3964         switch(sciGetEntityType(pobjUID))
3965     {
3966     case SCI_SUBWIN:
3967         pSUBWIN_FEATURE(pobjUID)->logflags[0] = logFlags[0];
3968         pSUBWIN_FEATURE(pobjUID)->logflags[1] = logFlags[1];
3969         pSUBWIN_FEATURE(pobjUID)->logflags[2] = logFlags[2];
3970
3971
3972
3973         return 0;
3974     default:
3975         printSetGetErrorMessage("log_flags");
3976         return -1;
3977     }
3978 #endif
3979         return -1;
3980 }
3981 /*----------------------------------------------------------------------------------*/
3982 /**
3983  * Set the log flags of a subwindow
3984  */
3985 int sciSetLogFlags(char * pobjUID, char logFlags[3])
3986 {
3987     char curLogFlags[3];
3988     int status;
3989     sciGetLogFlags(pobjUID, curLogFlags);
3990     if (   logFlags[0] == curLogFlags[0] && logFlags[1] == curLogFlags[1]
3991            && logFlags[2] == curLogFlags[2])
3992     {
3993         // nothing to do
3994         return 1;
3995     }
3996     status = sciInitLogFlags(pobjUID, logFlags);
3997
3998     // force redraw of all children of the object.
3999     if (status == 0 && pobjUID != getAxesModel())
4000     {
4001         forceHierarchyRedraw(pobjUID);
4002     }
4003
4004     return status;
4005 }
4006 /*----------------------------------------------------------------------------------*/
4007 int sciInitAutoTicks(char * pobjUID, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
4008 {
4009     // FIXME
4010     abort();
4011 #if 0
4012         switch(sciGetEntityType(pobjUID))
4013     {
4014     case SCI_SUBWIN:
4015         pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[0] = autoTicksX;
4016         pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[1] = autoTicksY;
4017         pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[2] = autoTicksZ;
4018         return 0;
4019     default:
4020         printSetGetErrorMessage("auto_ticks");
4021         return -1;
4022     }
4023 #endif
4024         return -1;
4025 }
4026 /*----------------------------------------------------------------------------------*/
4027 int sciSetAutoTicks(char * pobjUID, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
4028 {
4029     BOOL curAutoTicks[3];
4030     sciGetAutoTicks(pobjUID, curAutoTicks);
4031
4032     if (curAutoTicks[0] == autoTicksX && curAutoTicks[1] == autoTicksY && curAutoTicks[2] == autoTicksZ)
4033     {
4034         // nothing to do
4035         return 1;
4036     }
4037
4038     return sciInitAutoTicks(pobjUID, autoTicksX, autoTicksY, autoTicksZ);
4039
4040 }
4041 /*----------------------------------------------------------------------------------*/
4042 /**
4043  * Specify a new zoom box for a subwin object.
4044  * @param zoomBox [xMin, xMax, yMin, yMax, zMin, zMax] vector.
4045  */
4046 int sciSetZoomBox(char * pobjUID, const double zoomBox[6])
4047 {
4048     // FIXME
4049     abort();
4050 #if 0
4051         switch(sciGetEntityType(pobjUID))
4052     {
4053     case SCI_SUBWIN:
4054         pSUBWIN_FEATURE(pobjUID)->ZRect[0] = zoomBox[0];
4055         pSUBWIN_FEATURE(pobjUID)->ZRect[1] = zoomBox[1];
4056         pSUBWIN_FEATURE(pobjUID)->ZRect[2] = zoomBox[2];
4057         pSUBWIN_FEATURE(pobjUID)->ZRect[3] = zoomBox[3];
4058         pSUBWIN_FEATURE(pobjUID)->ZRect[4] = zoomBox[4];
4059         pSUBWIN_FEATURE(pobjUID)->ZRect[5] = zoomBox[5];
4060         return 0;
4061     default:
4062         printSetGetErrorMessage("zoom_box");
4063         return -1;
4064     }
4065 #endif
4066         return -1;
4067 }
4068 /*----------------------------------------------------------------------------------*/
4069 int sciInitImmediateDrawingMode(char * pobjUID, BOOL autoRedraw)
4070 {
4071      // FIXME
4072     abort();
4073 #if 0
4074        switch(sciGetEntityType(pobjUID))
4075     {
4076     case SCI_FIGURE:
4077         pFIGURE_FEATURE(pobjUID)->auto_redraw = autoRedraw;
4078         return 0;
4079     default:
4080         printSetGetErrorMessage("immediate_drawing");
4081         return -1;
4082     }
4083 #endif
4084        return -1;
4085 }
4086 /*----------------------------------------------------------------------------------*/
4087 int sciSetImmediateDrawingMode(char * pobjUID, BOOL autoRedraw)
4088 {
4089     // FIXME
4090     abort();
4091 #if 0
4092         if (sciGetImmediateDrawingMode(pobjUID) == autoRedraw)
4093     {
4094         // nothing to do
4095         return 1;
4096     }
4097     return sciInitImmediateDrawingMode(pobjUID, autoRedraw);
4098 #endif
4099     return -1;
4100 }
4101 /*----------------------------------------------------------------------------------*/
4102 int sciInitUseNurbs(char * pobjUID, BOOL useNurbs)
4103 {
4104     // FIXME
4105     abort();
4106 #if 0
4107         switch (sciGetEntityType(pobjUID))
4108     {
4109     case SCI_SUBWIN:
4110         pSUBWIN_FEATURE(pobjUID)->useNurbsForArcs = useNurbs;
4111         return 0;
4112     case SCI_ARC:
4113         pARC_FEATURE(pobjUID)->useNurbs = useNurbs;
4114         return 0;
4115     default:
4116         printSetGetErrorMessage("drawing_method");
4117         return -1;
4118     }
4119 #endif
4120         return -1;
4121 }
4122 /*----------------------------------------------------------------------------------*/
4123 /**
4124  * Return whether the drawing of an arc object uses nurbs or lines
4125  */
4126 int sciSetUseNurbs(char * pobjUID, BOOL useNurbs)
4127 {
4128     if (sciGetUseNurbs(pobjUID) == useNurbs)
4129     {
4130         // nothing to do
4131         return 1;
4132     }
4133     return sciInitUseNurbs(pobjUID, useNurbs);
4134 }
4135 /*----------------------------------------------------------------------------------*/
4136 int sciInitIsUsingFractionalMetrics(char * pobjUID, BOOL useFractionalMetrics)
4137 {
4138     // FIXME
4139     abort();
4140 #if 0
4141         sciFont * fontContext = sciGetFontContext(pobjUID);
4142     if (fontContext != NULL)
4143     {
4144         fontContext->useFractionalMetrics = useFractionalMetrics;
4145         return 0;
4146     }
4147     printSetGetErrorMessage("fractional_font");
4148 #endif
4149     return -1;
4150 }
4151 /*----------------------------------------------------------------------------------*/
4152 /**
4153  * Return whether an arc object uses fractional metrics for text display
4154  */
4155 int sciSetIsUsingFractionalMetrics(char * pobjUID, BOOL useFractionalMetrics)
4156 {
4157     if (sciGetIsUsingFractionalMetrics(pobjUID) == useFractionalMetrics)
4158     {
4159         // nothing to do
4160         return 1;
4161     }
4162     return sciInitIsUsingFractionalMetrics(pobjUID, useFractionalMetrics);
4163 }
4164 /*----------------------------------------------------------------------------------*/
4165 int sciInitColorRange(char * pobjUID, int subset[2])
4166 {
4167     // FIXME
4168     abort();
4169 #if 0
4170         switch (sciGetEntityType(pobjUID))
4171     {
4172     case SCI_FEC:
4173                 pFEC_FEATURE(pobjUID)->colminmax[0] = subset[0];
4174                 pFEC_FEATURE(pobjUID)->colminmax[1] = subset[1];
4175                 return 0;
4176     default:
4177         printSetGetErrorMessage("color_range");
4178                 return -1;
4179     }
4180 #endif
4181         return -1;
4182 }
4183 /*----------------------------------------------------------------------------------*/
4184 /**
4185  * Modify the subset of colormap bounds used by a particular object (colminmax).
4186  */
4187 int sciSetColorRange(char * pobjUID, int subset[2])
4188 {
4189
4190         int curColorRange[2];
4191         sciGetColorRange(pobjUID, curColorRange);
4192         if (curColorRange[0] == subset[0] && curColorRange[1] == subset[1])
4193         {
4194                 /* nothing to do */
4195                 return 1;
4196         }
4197
4198         return sciInitColorRange(pobjUID, subset);
4199
4200 }
4201 /*----------------------------------------------------------------------------------*/
4202 int sciInitOutsideColors(char * pobjUID, int colors[2])
4203 {
4204      // FIXME
4205     abort();
4206 #if 0
4207        switch (sciGetEntityType(pobjUID))
4208     {
4209     case SCI_FEC:
4210                 pFEC_FEATURE(pobjUID)->colout[0] = colors[0];
4211                 pFEC_FEATURE(pobjUID)->colout[1] = colors[1];
4212                 return 0;
4213     default:
4214         printSetGetErrorMessage("outside_color");
4215                 return -1;
4216     }
4217 #endif
4218        return -1;
4219 }
4220 /*----------------------------------------------------------------------------------*/
4221 /**
4222  * Modify the color to use for an objects when it uses index outside of the colormap (colout).
4223  */
4224 int sciSetOutsideColors(char * pobjUID, int colors[2])
4225 {
4226
4227         int curColors[2];
4228         sciGetOutsideColor(pobjUID, curColors);
4229         if (curColors[0] == colors[0] && curColors[1] == colors[1])
4230         {
4231                 /* nothing to do */
4232                 return 1;
4233         }
4234
4235     return sciInitOutsideColors(pobjUID, colors);
4236 }
4237 /*----------------------------------------------------------------------------------*/
4238 int sciInitZBounds(char * pobjUID, double bounds[2])
4239 {
4240     // FIXME
4241     abort();
4242 #if 0
4243         switch (sciGetEntityType(pobjUID))
4244     {
4245     case SCI_FEC:
4246                 pFEC_FEATURE(pobjUID)->zminmax[0] = bounds[0];
4247                 pFEC_FEATURE(pobjUID)->zminmax[1] = bounds[1];
4248                 return 0;
4249     default:
4250         printSetGetErrorMessage("z_bounds");
4251                 return -1;
4252     }
4253 #endif
4254         return -1;
4255 }
4256 /*----------------------------------------------------------------------------------*/
4257 /**
4258  * Modify the Z range used by a fec object (zminmax).
4259  */
4260 int sciSetZBounds(char * pobjUID, double bounds[2])
4261 {
4262     double curBounds[2];
4263         sciGetZBounds(pobjUID, curBounds);
4264         if (curBounds[0] == bounds[0] && curBounds[1] == bounds[1])
4265         {
4266                 /* nothing to do */
4267                 return 1;
4268         }
4269
4270         return sciInitZBounds(pobjUID, bounds);
4271 }
4272 /*----------------------------------------------------------------------------------*/
4273 int sciInitGridFront(char * pobjUID, BOOL gridFront)
4274 {
4275     // FIXME
4276     abort();
4277 #if 0
4278         switch (sciGetEntityType(pobjUID))
4279     {
4280         case SCI_SUBWIN:
4281                 pSUBWIN_FEATURE(pobjUID)->gridFront = gridFront;
4282                 return 0;
4283         default:
4284         printSetGetErrorMessage("grid_position");
4285                 return -1;
4286     }
4287 #endif
4288         return -1;
4289 }
4290 /*----------------------------------------------------------------------------------*/
4291 /**
4292  * Modify whether the grid is drawn in background or foreground.
4293  */
4294 int sciSetGridFront(char * pobjUID, BOOL gridFront)
4295 {
4296         if (sciGetGridFront(pobjUID) == gridFront)
4297         {
4298                 /* nothing to do */
4299                 return 1;
4300         }
4301         return sciInitGridFront(pobjUID, gridFront);
4302 }
4303 /*----------------------------------------------------------------------------------*/
4304 int sciInitAntialiasingQuality(char * pobjUID, int quality)
4305 {
4306     // FIXME
4307     abort();
4308 #if 0
4309         switch (sciGetEntityType(pobjUID))
4310     {
4311         case SCI_FIGURE:
4312                 if (isFigureModel(pobjUID))
4313                 {
4314                         pFIGURE_FEATURE(pobjUID)->pModelData->antialiasingQuality = quality;
4315                 }
4316                 else
4317                 {
4318                         sciSetJavaAntialiasingQuality(pobjUID, quality);
4319                 }
4320                 return 0;
4321     default:
4322         printSetGetErrorMessage("anti_aliasing");
4323                 return -1;
4324     }
4325 #endif
4326         return -1;
4327 }
4328 /*----------------------------------------------------------------------------------*/
4329 /**
4330  * Modify the quality of antialiasing or disable it.
4331  * If quality if 0, the antialiasing is disabled,
4332  * otherwise it might be either 1, 2, 4, 8 or 16 and then
4333  * specifies the number of pass for antialiasing.
4334  * @param quality positive integer.
4335  */
4336 int sciSetAntialiasingQuality(char * pobjUID, int quality)
4337 {
4338     if (sciGetAntialiasingQuality(pobjUID) == quality)
4339         {
4340                 /* nothing to do */
4341                 return 1;
4342         }
4343         return sciInitAntialiasingQuality(pobjUID, quality);
4344 }
4345 /*----------------------------------------------------------------------------------*/
4346 int sciInitLegendLocation(char * pobjUID, sciLegendPlace location)
4347 {
4348     // FIXME
4349     abort();
4350 #if 0
4351         switch (sciGetEntityType(pobjUID))
4352     {
4353         case SCI_LEGEND:
4354                 pLEGEND_FEATURE(pobjUID)->place = location;
4355                 return 0;
4356         default:
4357         printSetGetErrorMessage("legend_location");
4358                 return -1;
4359     }
4360 #endif
4361         return -1;
4362 }
4363 /*----------------------------------------------------------------------------------*/
4364 /**
4365  * Modify the legend position relatively to the subwindow
4366  */
4367 int sciSetLegendLocation(char * pobjUID, sciLegendPlace location)
4368 {
4369         if (sciGetLegendLocation(pobjUID) == location)
4370         {
4371                 /* nothing to do */
4372                 return 1;
4373         }
4374         return sciInitLegendLocation(pobjUID, location);
4375 }
4376 /*----------------------------------------------------------------------------------*/
4377 /**
4378  * Check that a color index is within the colormap range or not
4379  * @param pobjUID object conatining the color
4380  */
4381 BOOL sciCheckColorIndex(char * pobjUID, int colorIndex)
4382 {
4383     return (colorIndex >= -2) && (colorIndex <= sciGetNumColors(pobjUID) + 2);
4384 }
4385 /*----------------------------------------------------------------------------------*/