Remove xor (Space Sheriff Gavan) graphic object attribute.
[scilab.git] / scilab / modules / graphics / src / c / GetProperty.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) 2002 - 2004 - INRIA - Serge Steer
6  * Copyright (C) 2004 - 2006 - INRIA - Fabrice Leray
7  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
8  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
9  * Copyright (C) 2010 - Paul Griffiths
10  *
11  * This file must be used under the terms of the CeCILL.
12  * This source file is licensed as described in the file COPYING, which
13  * you should have received as part of this distribution.  The terms
14  * are also available at
15  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
16  *
17  */
18
19 /*------------------------------------------------------------------------
20  *    Graphic library
21  *    newGraph Library header
22  *    Comment:
23  *    This file contains all functions used to GET the properties of graphics
24  *    objects.
25  --------------------------------------------------------------------------*/
26
27 #include <stdio.h>
28
29 #include "GetProperty.h"
30 #include "Scierror.h"
31 #include "InitObjects.h"
32 #include "CurrentFigure.h"
33 #include "ObjectSelection.h"
34 #include "GetJavaProperty.h"
35 #include "BasicAlgos.h"
36 #include "localization.h"
37 #include "Axes.h"
38 #include "stack-c.h"
39 #include "HandleManagement.h"
40
41 #include "MALLOC.h" /* MALLOC */
42
43 #include "graphicObjectProperties.h"
44 #include "getGraphicObjectProperty.h"
45 #include "FigureModel.h"
46
47 /**sciGetEntityType
48 * Gets the type of this Scilab graphic object return -1 if bad param !
49 */
50 sciEntityType
51 sciGetEntityType (sciPointObj * pobj)
52 {
53     // TODO
54     // Call assert to force no more call to this method.
55     printf("[ABORT] sciGetEntityType must no more be called.\n");
56     printf("[ABORT] scilab will now abort.\n");
57     abort();
58
59     if (pobj != (sciPointObj *) NULL)
60         return pobj->entitytype;
61     return (sciEntityType)-1;
62 }
63
64
65 /**sciGetGraphicContext
66 * Returns the structure of the Graphic Context. Do not use this in the Consturctor Functions !
67 */
68 sciGraphicContext *
69 sciGetGraphicContext (sciPointObj * pobj)
70 {
71     switch (sciGetEntityType (pobj))
72     {
73     case SCI_FIGURE:
74         return &(pFIGURE_FEATURE (pobj)->graphiccontext);
75         break;
76     case SCI_SUBWIN:
77         return  &(pSUBWIN_FEATURE (pobj)->graphiccontext);
78         break;
79     case SCI_ARC:
80         return  &(pARC_FEATURE (pobj)->graphiccontext);
81         break;
82     case SCI_SEGS:
83         return  &(pSEGS_FEATURE (pobj)->graphiccontext);
84         break;
85     case SCI_FEC:
86         return  &(pFEC_FEATURE (pobj)->graphiccontext);
87         break;
88     case SCI_GRAYPLOT:
89         return  &(pGRAYPLOT_FEATURE (pobj)->graphiccontext);
90         break;
91     case SCI_POLYLINE:
92         return  &(pPOLYLINE_FEATURE (pobj)->graphiccontext);
93         break;
94     case SCI_RECTANGLE:
95         return  &(pRECTANGLE_FEATURE (pobj)->graphiccontext);
96         break;
97     case SCI_SURFACE:
98         return  &(pSURFACE_FEATURE (pobj)->graphiccontext);
99         break;
100     case SCI_AXES:
101         return  &(pAXES_FEATURE (pobj)->graphiccontext);
102         break;
103     case SCI_LEGEND:
104         return  &(pLEGEND_FEATURE (pobj)->graphiccontext);
105         break;
106     case SCI_TEXT:
107         return  &(pTEXT_FEATURE (pobj)->graphiccontext);
108         break;
109     case SCI_LABEL: /* F.Leray 28.05.04, modif JB.Silvy 03/06 */
110         return sciGetGraphicContext( pLABEL_FEATURE(pobj)->text );
111     case SCI_AGREG:
112     case SCI_UIMENU:
113     default:
114         return (sciGraphicContext *) NULL;
115         break;
116     }
117     return (sciGraphicContext *) NULL;
118 }
119
120
121 /**sciGetNumColors
122 * This function gets the number of the color defined in colormap
123 */
124 int
125 sciGetNumColors (char *pobjUID)
126 {
127     if (pobjUID)
128     {
129         char* parentFigure;
130         int iNumColors = 0;
131         int* piNumColors = &iNumColors;
132
133         getGraphicObjectProperty(pobjUID, __GO_PARENT_FIGURE__, jni_string, &parentFigure);
134         getGraphicObjectProperty(parentFigure, __GO_COLORMAP_SIZE__, jni_int, &piNumColors);
135
136         return iNumColors;
137     }
138     return -1;
139 }
140
141
142 /**sciGetColormap
143 * This function gets a colormap from the figure. It's the same for all sons
144 * Gets the colormap rgbmat must be a m x 3 double RGB matrix:
145 * a[i] = RED, a[i+m] = GREEN, a[i+2*m] = BLUE
146 */
147 int sciGetColormap(sciPointObj * pobj, double rgbmat[] )
148 {
149     if ( pobj == getFigureModel() )
150     {
151         doubleArrayCopy( rgbmat, pFIGURE_FEATURE(pobj)->pModelData->colorMap , pFIGURE_FEATURE(pobj)->pModelData->numColors ) ;
152     }
153     else
154     {
155         sciGetJavaColormap( pobj, rgbmat ) ;
156     }
157
158     return 0 ;
159 }
160
161 /* This function */
162 int sciGetGoodIndex(sciPointObj * pobj, int colorindex) /* return colorindex or m (Default Black) or m+1 (Default White)*/
163 {
164     int m = sciGetNumColors (pobj);     /* the number of the color*/
165
166     if(colorindex == -1) /* Black */
167         return m + 1;
168     else if(colorindex == -2) /* White */
169         return m + 2;
170     else
171         return colorindex;
172 }
173
174
175
176 /**sciGetForeground
177 * Gets the color number of the Foreground
178 */
179 int
180 sciGetForeground (sciPointObj * pobj)
181 {
182
183     int colorindex = -999;
184
185     if(sciGetGraphicContext(pobj) != NULL)
186     {
187         colorindex = (sciGetGraphicContext(pobj))->foregroundcolor + 1;
188     }
189     else
190     {
191         /*printSetGetErrorMessage("foreground");*/ /* rewrite updatebaw to renable this message */
192         return -999;
193     }
194
195     colorindex = sciGetGoodIndex(pobj, colorindex);
196
197     return colorindex;
198 }
199
200
201 int
202 sciGetForegroundToDisplay (sciPointObj * pobj)
203 {
204
205     int colorindex = -999;
206     int m = sciGetNumColors(pobj);
207
208     colorindex = sciGetForeground(pobj);
209
210     if((m - colorindex == -1) || (m - colorindex == -2)) colorindex =  m - colorindex;
211
212     return colorindex;
213 }
214
215
216 /**sciGetBackground
217 * Gets the color number of the Background. Be carreful the return of the subwindow
218 * is the feature of its parent figure.
219 */
220 int
221 sciGetBackground (sciPointObj * pobj)
222 {
223
224     int colorindex = -999;
225
226     if(sciGetGraphicContext(pobj) != NULL)
227     {
228         colorindex = (sciGetGraphicContext(pobj))->backgroundcolor + 1;
229     }
230     else
231     {
232         /*printSetGetErrorMessage("background");*/ /* rewrite updatebaw to renable this message */
233         return -999;
234     }
235
236     colorindex = sciGetGoodIndex(pobj, colorindex);
237
238     return colorindex;
239 }
240
241
242
243 /* F.Leray 01.04.04*/
244 /* Adding sciGet____groundToDisplay to display the correct index*/
245 int
246 sciGetBackgroundToDisplay (sciPointObj * pobj)
247 {
248
249     int colorindex = -999;
250     int m = sciGetNumColors(pobj);
251
252     colorindex = sciGetBackground(pobj);
253
254     if((m - colorindex == -1) || (m - colorindex == -2)) colorindex =  m - colorindex;
255
256     return colorindex;
257 }
258
259
260 /**sciGetMarkForeground
261 * Gets the color number of the Marks'Foreground
262 */
263 int
264 sciGetMarkForeground (sciPointObj * pobj)
265 {
266
267     int colorindex = -999;
268
269     if (sciGetGraphicContext(pobj) != NULL)
270     {
271         colorindex = sciGetGraphicContext(pobj)->markforeground + 1;
272     }
273     else
274     {
275         printSetGetErrorMessage("mark_foreground");
276         return -1;
277     }
278
279     colorindex = sciGetGoodIndex(pobj, colorindex);
280
281     return colorindex;
282 }
283
284
285 int
286 sciGetMarkForegroundToDisplay (sciPointObj * pobj)
287 {
288
289     int colorindex = -999;
290     int m = sciGetNumColors(pobj);
291
292     colorindex = sciGetMarkForeground(pobj);
293
294     if((m - colorindex == -1) || (m - colorindex == -2)) colorindex =  m - colorindex;
295
296     return colorindex;
297 }
298
299
300
301 /**sciGetMarkBackground
302 * Gets the color number of the Marks'Background. Be carreful the return of the subwindow
303 * is the feature of its parent figure.
304 */
305 int
306 sciGetMarkBackground (sciPointObj * pobj)
307 {
308
309     int colorindex = -999;
310
311     if (sciGetGraphicContext(pobj) != NULL)
312     {
313         colorindex = sciGetGraphicContext(pobj)->markbackground + 1;
314     }
315     else
316     {
317         printSetGetErrorMessage("mark_background");
318         return -1;
319     }
320
321     return sciGetGoodIndex(pobj, colorindex);
322
323 }
324
325
326
327 /* F.Leray 01.04.04*/
328 /* Adding sciGet____groundToDisplay to display the correct index*/
329 int
330 sciGetMarkBackgroundToDisplay (sciPointObj * pobj)
331 {
332
333     int colorindex = -999;
334     int m = sciGetNumColors(pobj);
335
336     colorindex = sciGetMarkBackground(pobj);
337
338     if((m - colorindex == -1) || (m - colorindex == -2)) colorindex =  m - colorindex;
339
340     return colorindex;
341 }
342
343
344 /**sciGetLineWidth
345 * Gets the line width
346 */
347 double sciGetLineWidth (sciPointObj * pobj)
348 {
349     if (sciGetGraphicContext(pobj) != NULL)
350     {
351         return sciGetGraphicContext(pobj)->linewidth;
352     }
353     printSetGetErrorMessage("thickness");
354     return -1;
355 }
356
357
358 /**sciGetLineStyle
359 * Gets the line style
360 */
361 int
362 sciGetLineStyle (sciPointObj * pobj)
363 {
364     if (sciGetGraphicContext(pobj) != NULL)
365     {
366         return sciGetGraphicContext(pobj)->linestyle;
367     }
368     printSetGetErrorMessage("line_style");
369     return -1;
370 }
371
372
373 /**sciGetIsMark
374 * Gets the line style
375 */
376 BOOL
377 sciGetIsMark (sciPointObj * pobj)
378 {
379     if(sciGetGraphicContext(pobj) != NULL)
380     {
381         return sciGetGraphicContext(pobj)->ismark;
382     }
383     printSetGetErrorMessage("mark_mode");
384     return FALSE;
385 }
386
387
388 /**sciGetMarkStyle
389 * Gets the mark style
390 */
391 int
392 sciGetMarkStyle (sciPointObj * pobj)
393 {
394
395     if (sciGetGraphicContext(pobj) != NULL)
396     {
397         return (sciGetGraphicContext(pobj))->markstyle;
398     }
399
400     printSetGetErrorMessage("mark_style");
401     return -1;
402
403 }
404
405
406
407 /**sciGetMarkSize
408 * Gets the mark size
409 */
410 int
411 sciGetMarkSize (sciPointObj * pobj)
412 {
413
414     if (sciGetGraphicContext(pobj) != NULL )
415     {
416         return sciGetGraphicContext(pobj)->marksize;
417     }
418
419     printSetGetErrorMessage("mark_size");
420     return -1;
421 }
422
423
424 /**sciGetMarkSizeUnit
425 * Gets the mark size unit
426 * 1 : points, 2 : tabulated
427 */
428 int
429 sciGetMarkSizeUnit (sciPointObj * pobj)
430 {
431     if (sciGetGraphicContext(pobj) != NULL)
432     {
433         return (sciGetGraphicContext(pobj))->marksizeunit;
434     }
435
436     printSetGetErrorMessage("mark_size_unit");
437     return -1;
438
439 }
440
441 /**sciGetIsLine
442 * Returns the line drawing existence
443 */
444 BOOL
445 sciGetIsLine (sciPointObj * pobj)
446 {
447
448     if (sciGetGraphicContext(pobj) != NULL)
449     {
450         return sciGetGraphicContext(pobj)->isline;
451     }
452     else
453     {
454         printSetGetErrorMessage("line_mode");
455         return FALSE;
456     }
457 }
458
459 /**
460 * @return TRUE if the object is actually displaying lines.
461 */
462 BOOL sciGetIsDisplayingLines(sciPointObj * pObj)
463 {
464     return sciGetIsLine(pObj) && (sciGetLineWidth(pObj) > 0.0);
465 }
466
467 /**sciGetIsFilled
468 * Returns the filled line existence
469 */
470 BOOL
471 sciGetIsFilled (sciPointObj * pobj)
472 {
473     switch (sciGetEntityType (pobj))
474     {
475     case SCI_SUBWIN:
476         return pSUBWIN_FEATURE(pobj)->axes.filled;
477     default:
478         if (sciGetGraphicContext(pobj) != NULL)
479         {
480             return sciGetGraphicContext(pobj)->isfilled;
481         }
482         else
483         {
484             printSetGetErrorMessage("fill_mode");
485             return FALSE;
486         }
487     }
488 }
489
490
491
492 /**sciGetFontContext
493 * Returns the structure of the Font Context. Do not use this in the Consturctor Functions !
494 * @param sciPointObj * pobj: the pointer to the entity
495 * @return the pointer to the font context structure if ok, NULL if not
496 */
497 sciFont *
498 sciGetFontContext (sciPointObj * pobj)
499 {
500     switch (sciGetEntityType (pobj))
501     {
502     case SCI_TEXT:
503         return  &(pTEXT_FEATURE (pobj)->fontcontext);
504         break;
505     case SCI_LEGEND:
506         return  &(pLEGEND_FEATURE (pobj)->text.fontcontext);
507         break;
508     case SCI_SUBWIN: /* F.Leray 08.04.04 THE MOST IMPORTANT*/
509         return &(pSUBWIN_FEATURE (pobj)->axes.fontcontext);
510         break;
511     case SCI_AXES:
512         return  &(pAXES_FEATURE (pobj)->fontcontext);
513         break;
514     case SCI_FIGURE: /* F.Leray 08.04.04 THE MOST IMPORTANT*/
515         return &(pFIGURE_FEATURE (pobj)->fontcontext);
516         break;
517     case SCI_LABEL: /* F.Leray 27.05.04 */
518         return sciGetFontContext( pLABEL_FEATURE(pobj)->text ) ;
519         break;
520     case SCI_ARC:
521     case SCI_SEGS:
522     case SCI_FEC:
523     case SCI_GRAYPLOT:
524     case SCI_POLYLINE:
525     case SCI_RECTANGLE:
526     case SCI_SURFACE:
527     case SCI_AGREG:
528     case SCI_UIMENU:
529     default:
530         return (sciFont *)NULL;
531         break;
532     }
533 }
534
535
536
537 /****************************************** TEXT ******************************
538 **sciGetFontSize
539 * Gets the Font Size
540 */
541 double sciGetFontSize(char * pobjUID)
542 {
543     abort();
544 #if 0
545     if (sciGetFontContext(pobj) != NULL)
546     {
547         return (sciGetFontContext(pobj))->fontSize;
548     }
549     else
550     {
551         printSetGetErrorMessage("font_size");
552         return -1.0;
553     }
554 #endif
555 }
556
557
558 /*sciGetFontOrientation
559 * gets the Font Orientation
560 */
561 double
562 sciGetFontOrientation (sciPointObj * pobj)
563 {
564
565     if (sciGetFontContext(pobj) != NULL)
566     {
567         return (sciGetFontContext(pobj))->textorientation;
568     }
569     printSetGetErrorMessage("font_angle");
570     return 0.0;
571
572 }
573
574
575
576
577 /**sciGetText
578 * Gets the Text in TEXT, TITLE or LEGEND. Be Carreful,
579 * this return a unterminated string (without \0)
580 * To obtain the length of the text, use sciGetTextLength@param  sciPointObj *pobj
581 * @param sciPointObj * pobj: the pointer to the entity
582 * @return  point to char[] if OK or NULL if not
583 */
584 StringMatrix * sciGetText( sciPointObj * pobj )
585 {
586
587     switch (sciGetEntityType (pobj))
588     {
589     case SCI_TEXT:
590         return pTEXT_FEATURE (pobj)->pStrings;
591         break;
592     case SCI_LEGEND:
593         return pLEGEND_FEATURE (pobj)->text.pStrings;
594         break;
595     case SCI_LABEL: /* F.Leray 28.05.04 */
596         return sciGetText( pLABEL_FEATURE (pobj)->text ) ;
597         break;
598     case SCI_UIMENU:
599     case SCI_FIGURE:
600     case SCI_SUBWIN:
601     case SCI_ARC:
602     case SCI_SEGS:
603     case SCI_FEC:
604     case SCI_GRAYPLOT:
605     case SCI_POLYLINE:
606     case SCI_RECTANGLE:
607     case SCI_SURFACE:
608     case SCI_AXES:
609     case SCI_AGREG:
610     default:
611         return  NULL;
612         break;
613     }
614 }
615
616 /**
617 * Get the size of the string matrix of a text object
618 * @param nbRow, number of row of the text conatianed in pobj
619 *        If an error occures, the value is negative.
620 * @param nbCol, same as nbRow for columns.
621 */
622 void sciGetTextSize( sciPointObj * pobj, int * nbRow, int * nbCol )
623 {
624     StringMatrix * text = sciGetText( pobj ) ;
625     if ( text == NULL )
626     {
627         *nbRow = -1 ;
628         *nbCol = -1 ;
629     }
630     else
631     {
632         *nbRow = getMatNbRow( text ) ;
633         *nbCol = getMatNbCol( text ) ;
634     }
635 }
636 /**
637 * Checks if a text object is empty #rows*#columns==0 or #rows*#columns==1 and entry is  zero length
638 * This function has been adapted to the MVC: its parameter's type has been changed from sciPointObj to char*
639 * (MVC identifier), the reason being that it is exclusively used to get the properties of Label objects,
640 * which can be only be known by their MVC identifiers at the present moment.
641 */
642 //BOOL sciisTextEmpty( sciPointObj * pobj)
643
644 BOOL sciisTextEmpty(char* identifier)
645 {
646     int nbElements;
647     int* dimensions;
648
649     getGraphicObjectProperty(identifier, __GO_TEXT_ARRAY_DIMENSIONS__, jni_int_vector, &dimensions);
650
651     if (dimensions == NULL)
652     {
653         return TRUE;
654     }
655
656     nbElements = dimensions[0]*dimensions[1];
657
658     if (nbElements == 0)
659     {
660         return TRUE;
661     }
662
663     if (nbElements == 1)
664     {
665         char** textMatrix;
666         getGraphicObjectProperty(identifier, __GO_TEXT_STRINGS__, jni_string_vector, &textMatrix);
667
668         if (textMatrix[0] == NULL)
669         {
670             return TRUE;
671         }
672         else if (strcmp(textMatrix[0], "") == 0)
673         {
674             /* empty string */
675             return TRUE;
676         }
677
678     }
679
680     return FALSE;
681 }
682
683
684 /**sciGetFontBackground
685 * Gets the background color
686 * @param sciPointObj * pobj: the pointer to the entity
687 * @return  int color if OK, -1 if not
688 */
689 int
690 sciGetFontBackground (sciPointObj * pobj)
691 {
692
693     int colorindex = -999;
694
695     switch (sciGetEntityType (pobj))
696     {
697     case SCI_TEXT:
698     case SCI_LEGEND:
699     case SCI_AXES:
700     case SCI_SUBWIN: /* F.Leray 08.04.04 */
701     case SCI_FIGURE: /* F.Leray 08.04.04 */
702     case SCI_LABEL:  /* F.Leray 28.05.04 */
703         colorindex = (sciGetFontContext(pobj))->backgroundcolor+1; /* +1 added by F.Leray 25.06.04 */
704         break;
705     case SCI_ARC:
706     case SCI_SEGS:
707     case SCI_FEC:
708     case SCI_GRAYPLOT:
709     case SCI_POLYLINE:
710     case SCI_RECTANGLE:
711     case SCI_SURFACE:
712     case SCI_AGREG:
713     case SCI_UIMENU:
714     default:
715         return -1;
716         break;
717     }
718
719     colorindex = sciGetGoodIndex(pobj, colorindex); /* Adding F.Leray 31.03.04*/
720     return colorindex;
721 }
722
723
724 /**sciGetFontBackgroundToDisplay
725 */
726 int
727 sciGetFontBackgroundToDisplay (sciPointObj * pobj)
728 {
729
730     int colorindex = -999;
731     int m = sciGetNumColors(pobj);
732
733     switch (sciGetEntityType (pobj))
734     {
735     case SCI_TEXT:
736     case SCI_LEGEND:
737     case SCI_AXES:
738     case SCI_SUBWIN: /* F.Leray 08.04.04 */
739     case SCI_FIGURE: /* F.Leray 08.04.04 */
740     case SCI_LABEL:  /* F.Leray 28.05.04 */
741         colorindex = (sciGetFontContext(pobj))->backgroundcolor;
742         break;
743     case SCI_ARC:
744     case SCI_SEGS:
745     case SCI_FEC:
746     case SCI_GRAYPLOT:
747     case SCI_POLYLINE:
748     case SCI_RECTANGLE:
749     case SCI_SURFACE:
750     case SCI_AGREG:
751     case SCI_UIMENU:
752     default:
753         printSetGetErrorMessage("font_background");
754         return -1;
755         break;
756     }
757
758     colorindex = sciGetGoodIndex(pobj, colorindex); /* Adding F.Leray 31.03.04*/
759
760     if((m - colorindex == -1) || (m - colorindex == -2)) colorindex =  m - colorindex;
761
762     return colorindex;
763 }
764
765
766
767 /**sciGetFontForeground
768 * Gets the foreground color
769 * @param sciPointObj * pobj: the pointer to the entity
770 * @return  int foregroundcolor if OK, -1 if not
771 */
772 int
773 sciGetFontForeground (sciPointObj * pobj)
774 {
775
776     int colorindex = -999;
777
778     switch (sciGetEntityType (pobj))
779     {
780     case SCI_TEXT:
781     case SCI_LEGEND:
782     case SCI_AXES:
783     case SCI_SUBWIN:  /* F.Leray 08.04.04 */
784     case SCI_FIGURE:  /* F.Leray 08.04.04 */
785     case SCI_LABEL:   /* F.Leray 28.05.04 */
786         colorindex =  (sciGetFontContext(pobj))->foregroundcolor + 1 ; /* Modif. F.Leray 31.03.04*/
787         break;
788     case SCI_ARC:
789     case SCI_SEGS:
790     case SCI_FEC:
791     case SCI_GRAYPLOT:
792     case SCI_POLYLINE:
793     case SCI_RECTANGLE:
794     case SCI_SURFACE:
795     case SCI_AGREG:
796     case SCI_UIMENU:
797     default:
798         printSetGetErrorMessage("font_foreground");
799         return -1;
800         break;
801     }
802
803     colorindex = sciGetGoodIndex(pobj, colorindex); /* Adding F.Leray 31.03.04*/
804     return colorindex;
805 }
806
807
808 /**sciGetFontForegroundToDisplay
809 */
810 int
811 sciGetFontForegroundToDisplay (sciPointObj * pobj)
812 {
813
814     int colorindex = -999;
815     int m = sciGetNumColors(pobj);
816
817     switch (sciGetEntityType (pobj))
818     {
819     case SCI_TEXT:
820     case SCI_LEGEND:
821     case SCI_AXES:
822     case SCI_SUBWIN:  /* F.Leray 08.04.04 */
823     case SCI_FIGURE:  /* F.Leray 08.04.04 */
824     case SCI_LABEL:   /* F.Leray 28.05.04 */
825         colorindex =  (sciGetFontContext(pobj))->foregroundcolor + 1 ; /* Modif. F.Leray 31.03.04*/
826         break;
827     case SCI_ARC:
828     case SCI_SEGS:
829     case SCI_FEC:
830     case SCI_GRAYPLOT:
831     case SCI_POLYLINE:
832     case SCI_RECTANGLE:
833     case SCI_SURFACE:
834     case SCI_AGREG:
835     case SCI_UIMENU:
836     default:
837         printSetGetErrorMessage("font_foreground");
838         return -1;
839         break;
840     }
841
842     colorindex = sciGetGoodIndex(pobj, colorindex); /* Adding F.Leray 31.03.04*/
843
844     if((m - colorindex == -1) || (m - colorindex == -2)) colorindex =  m - colorindex;
845
846     return colorindex;
847 }
848
849
850 /**sciGetFontStyle
851 * Gets the font style
852
853 * @param sciPointObj * pobj: the pointer to the entity
854 * @return  int 0 OK, -1 if not
855 */
856 int
857 sciGetFontStyle (sciPointObj * pobj)
858 {
859
860
861     switch (sciGetEntityType (pobj))
862     {
863     case SCI_TEXT:
864     case SCI_LEGEND:
865     case SCI_SUBWIN:
866     case SCI_FIGURE:
867     case SCI_LABEL: /* F.Leray 10.06.04 */
868     case SCI_AXES:
869         return sciGetFontContext(pobj)->fonttype;
870         break;
871     case SCI_ARC:
872     case SCI_SEGS:
873     case SCI_FEC:
874     case SCI_GRAYPLOT:
875     case SCI_POLYLINE:
876     case SCI_RECTANGLE:
877     case SCI_SURFACE:
878     case SCI_AGREG:
879     case SCI_UIMENU:
880     default:
881         printSetGetErrorMessage("font_style");
882         return -1;
883         break;
884     }
885 }
886
887
888 /**sciGetLegendPlace
889 * Returns the Title place with SCI_TITLE_IN_TOP or SCI_TITLE_IN_BOTTOM and calculate the real position in the window
890 * @param sciPointObj * pobj: the pointer to the entity
891 * @return sciTitlePlace
892 */
893 sciLegendPlace
894 sciGetLegendPlace (sciPointObj * pobj)
895 {
896     if ( sciGetEntityType(pobj) == SCI_LEGEND )
897     {
898         return pLEGEND_FEATURE (pobj)->place ;
899     }
900     else
901     {
902         Scierror(999, _("You are not using a legend object.\n"));
903         return SCI_LEGEND_OUT_LOWER_LEFT;
904     }
905     return SCI_LEGEND_OUT_LOWER_LEFT;
906 }
907
908
909
910 /**sciGetLegendPos
911 * Returns the Title Position
912 */
913
914 void sciGetLegendPos (sciPointObj * pobj, double position[2])
915 {
916     POINT2D tmppoint;
917     if (sciGetEntityType (pobj) == SCI_LEGEND) {
918         tmppoint= pLEGEND_FEATURE (pobj)->pos;
919         position[0] = tmppoint.x;
920         position[1] = tmppoint.y;
921     }
922
923     else
924     {
925         position[0] = -1;
926         position[1] = -1;
927         Scierror(999, _("You are not using a legend object.\n"));
928         return;
929     }
930 }
931
932
933
934
935 /**sciGetParentFigure
936 * Returns the the Figure parent
937 */
938 sciPointObj *
939 sciGetParentFigure (sciPointObj * pobj)
940 {
941
942     if (pobj == NULL)
943     {
944         return NULL;
945     }
946
947     switch (sciGetEntityType (pobj))
948     {
949     case SCI_FIGURE:
950         return pobj ;
951     case SCI_TEXT:
952     case SCI_LEGEND:
953     case SCI_ARC:
954     case SCI_SEGS:
955     case SCI_FEC:
956     case SCI_GRAYPLOT:
957     case SCI_POLYLINE:
958     case SCI_RECTANGLE:
959     case SCI_SURFACE:
960     case SCI_AXES:
961     case SCI_SUBWIN:
962     case SCI_AGREG:
963     case SCI_LABEL: /* F.Leray 28.05.04 */
964     case SCI_UICONTROL:
965     case SCI_UIMENU:
966         {
967             return sciGetParentFigure( sciGetParent( pobj ) ) ; /* jbs 06/2006 */
968         }
969         break;
970     default:
971         return NULL;
972         break;
973     }
974     return NULL;
975 }
976 /** 19/09/2002 ***/
977 /**sciGetParentSubwin
978 * Returns the the Subwin parent
979 */
980 sciPointObj *
981 sciGetParentSubwin (sciPointObj * pobj)
982 {
983     sciPointObj *subwin;
984
985     subwin = pobj;
986     switch (sciGetEntityType (pobj))
987     {
988     case SCI_FIGURE:
989         return sciGetFirstTypedSelectedSon( pobj, SCI_SUBWIN );
990         break;
991     case SCI_SUBWIN:
992     case SCI_TEXT:
993     case SCI_LEGEND:
994     case SCI_ARC:
995     case SCI_SEGS:
996     case SCI_FEC:
997     case SCI_GRAYPLOT:
998     case SCI_POLYLINE:
999     case SCI_RECTANGLE:
1000     case SCI_SURFACE:
1001     case SCI_AXES:
1002     case SCI_AGREG:
1003     case SCI_LABEL: /* F.Leray 28.05.04 */
1004     case SCI_UIMENU:
1005         while (sciGetEntityType(subwin) != SCI_SUBWIN)
1006             subwin=sciGetParent(subwin);
1007         return (sciPointObj *) subwin;
1008         break;
1009     default:
1010         return NULL;
1011         break;
1012     }
1013     return (sciPointObj *) NULL;
1014 }
1015
1016 /**sciGetNumfigure
1017 * Returns the the Number of parent figure
1018 */
1019 int
1020 sciGetNumFigure (sciPointObj * pobj)
1021 {
1022     sciPointObj *figure = pobj;
1023
1024     switch (sciGetEntityType (pobj))
1025     {
1026     case SCI_FIGURE:
1027         return  sciGetNum(figure) ;
1028         break;
1029     case SCI_SUBWIN:
1030     case SCI_TEXT:
1031     case SCI_LEGEND:
1032     case SCI_ARC:
1033     case SCI_SEGS:
1034     case SCI_FEC:
1035     case SCI_GRAYPLOT:
1036     case SCI_POLYLINE:
1037     case SCI_RECTANGLE:
1038     case SCI_SURFACE:
1039     case SCI_AXES:
1040     case SCI_AGREG:
1041     case SCI_LABEL: /* F.Leray 28.05.04 */
1042     case SCI_UIMENU:
1043         while (sciGetEntityType(figure) != SCI_FIGURE)
1044             figure=sciGetParent(figure);
1045         return sciGetNum(figure);
1046         break;
1047     default:
1048         return -1;
1049         break;
1050     }
1051     return -1;
1052 }
1053
1054 /**sciGetGraphicMode
1055 * Returns the structure of the Graphic Context. Do not use this in the Consturctor Functions !
1056 */
1057 scigMode *sciGetGraphicMode (sciPointObj * pobj)
1058 {
1059     switch (sciGetEntityType (pobj))
1060     {
1061     case SCI_FIGURE:
1062         return &(pFIGURE_FEATURE (pobj)->gmode);
1063         break;
1064     case SCI_SUBWIN:
1065         return &(pSUBWIN_FEATURE (pobj)->gmode);
1066         break;
1067     case SCI_ARC:
1068     case SCI_SEGS:
1069     case SCI_FEC:
1070     case SCI_GRAYPLOT:
1071     case SCI_POLYLINE:
1072     case SCI_RECTANGLE:
1073     case SCI_SURFACE:
1074     case SCI_AXES:
1075     case SCI_AGREG:
1076     case SCI_TEXT:
1077     case SCI_LEGEND:
1078     case SCI_LABEL: /* F.Leray 28.05.04 */
1079     case SCI_UIMENU:
1080     default:
1081         return (scigMode *) NULL;
1082         break;
1083     }
1084     return (scigMode *) NULL;
1085 }
1086
1087
1088 /**sciGetIsClipRegionValuated*/
1089 /* To know if clip_region has been set at least once */
1090 /* (using sciSetClipping) */
1091 int
1092 sciGetIsClipRegionValuated (sciPointObj * pobj)
1093 {
1094     switch (sciGetEntityType (pobj))
1095     {
1096     case SCI_SUBWIN:
1097         return pSUBWIN_FEATURE (pobj)->clip_region_set;
1098         break;
1099     case SCI_ARC:
1100         return pARC_FEATURE (pobj)->clip_region_set;
1101         break;
1102     case SCI_POLYLINE:
1103         return pPOLYLINE_FEATURE (pobj)->clip_region_set;
1104         break;
1105     case SCI_RECTANGLE:
1106         return pRECTANGLE_FEATURE (pobj)->clip_region_set;
1107         break;
1108     case SCI_SEGS:
1109         return pSEGS_FEATURE (pobj)->clip_region_set;
1110         break;
1111     case SCI_TEXT:
1112         return pTEXT_FEATURE (pobj)->clip_region_set;
1113         break;
1114     case SCI_AXES:
1115         return pAXES_FEATURE (pobj)->clip_region_set;
1116         break;
1117     case SCI_SURFACE:
1118         return pSURFACE_FEATURE (pobj)->clip_region_set;
1119         break;
1120     case SCI_FEC:
1121         return pFEC_FEATURE (pobj)->clip_region_set;
1122         break;
1123     case SCI_GRAYPLOT:
1124         return pGRAYPLOT_FEATURE (pobj)->clip_region_set;
1125         break;
1126     case SCI_LEGEND:
1127         return pLEGEND_FEATURE(pobj)->clip_region_set;
1128     case SCI_AGREG:
1129     case SCI_FIGURE:
1130     case SCI_LABEL: /* F.Leray 28.05.04 */
1131     case SCI_UIMENU:
1132     default:
1133         return -2;
1134         break;
1135     }
1136     return -2;
1137 }
1138
1139
1140 /**sciGetIsClipping*/
1141 int
1142 sciGetIsClipping (sciPointObj * pobj)
1143 {
1144     switch (sciGetEntityType (pobj))
1145     {
1146
1147     case SCI_SUBWIN:
1148         return pSUBWIN_FEATURE (pobj)->isclip;
1149         break;
1150     case SCI_ARC:
1151         return pARC_FEATURE (pobj)->isclip;
1152         break;
1153     case SCI_POLYLINE:
1154         return pPOLYLINE_FEATURE (pobj)->isclip;
1155         break;
1156     case SCI_RECTANGLE:
1157         return pRECTANGLE_FEATURE (pobj)->isclip;
1158         break;
1159     case SCI_SEGS:
1160         return pSEGS_FEATURE (pobj)->isclip;
1161         break;
1162     case SCI_TEXT:
1163         return pTEXT_FEATURE (pobj)->isclip;
1164         break;
1165     case SCI_AXES:
1166         return pAXES_FEATURE (pobj)->isclip;
1167         break;
1168     case SCI_SURFACE:
1169         return pSURFACE_FEATURE(pobj)->isclip;
1170         break;
1171     case SCI_FEC:
1172         return pFEC_FEATURE(pobj)->isclip;
1173         break;
1174     case SCI_GRAYPLOT:
1175         return pGRAYPLOT_FEATURE(pobj)->isclip;
1176         break;
1177     case SCI_LEGEND:
1178         return pLEGEND_FEATURE(pobj)->isclip;
1179     case SCI_AGREG:
1180     case SCI_FIGURE:
1181     case SCI_LABEL: /* F.Leray 28.05.04 */
1182     case SCI_UIMENU:
1183     default:
1184         return -2;
1185         break;
1186     }
1187     return -2;
1188 }
1189
1190
1191 /**sciGetClipping
1192 * Gets the clipping area
1193 * 29/11/2002
1194 */
1195 double *
1196 sciGetClipping (sciPointObj * pobj)
1197 {
1198     switch (sciGetEntityType (pobj))
1199     {
1200
1201     case SCI_SUBWIN:
1202         return pSUBWIN_FEATURE (pobj)->clip_region;
1203         break;
1204     case SCI_ARC:
1205         return pARC_FEATURE (pobj)->clip_region;
1206         break;
1207     case SCI_POLYLINE:
1208         return pPOLYLINE_FEATURE (pobj)->clip_region;
1209         break;
1210     case SCI_RECTANGLE:
1211         return pRECTANGLE_FEATURE (pobj)->clip_region;
1212         break;
1213     case SCI_SEGS:
1214         return pSEGS_FEATURE (pobj)->clip_region;
1215         break;
1216     case SCI_TEXT:
1217         return pTEXT_FEATURE (pobj)->clip_region;
1218         break;
1219     case SCI_AXES:
1220         return pAXES_FEATURE (pobj)->clip_region;
1221         break;
1222     case SCI_LABEL:
1223         return sciGetClipping( pLABEL_FEATURE(pobj)->text ) ;
1224         break;
1225     case SCI_LEGEND:
1226         return pLEGEND_FEATURE (pobj)->clip_region;
1227         break;
1228     case SCI_SURFACE:
1229         return pSURFACE_FEATURE (pobj)->clip_region;
1230         break;
1231     case SCI_FEC:
1232         return pFEC_FEATURE (pobj)->clip_region;
1233         break;
1234     case SCI_GRAYPLOT:
1235         return pGRAYPLOT_FEATURE (pobj)->clip_region;
1236         break;
1237     case SCI_UIMENU:
1238     case SCI_AGREG:
1239     case SCI_FIGURE:
1240     default:
1241         printSetGetErrorMessage("clip_box");
1242         return (double *) NULL;
1243         break;
1244     }
1245     printSetGetErrorMessage("clip_box");
1246     return (double *) NULL;
1247
1248 }
1249
1250
1251 /**sciGetHighLight
1252 * Returns the highlight mode where the object are.
1253 */
1254
1255
1256 /**sciGetAddPlot
1257 * Returns the mode of the adding plot
1258 * @param sciPointObj * pobj: the pointer to the entity
1259 * @return TRUE if yes, FALSE if no
1260 * @author Djalel ABDEMOUCHE
1261 * 25/10/2002
1262 */
1263 BOOL
1264 sciGetAddPlot (sciPointObj * pobj)
1265 {
1266     switch (sciGetEntityType (pobj))
1267     {
1268     case SCI_FIGURE:
1269         return (sciGetGraphicMode (pobj))->addplot;
1270         break;
1271     case SCI_SUBWIN:
1272         return (sciGetGraphicMode (pobj))->addplot;
1273         break;
1274     case SCI_TEXT:
1275     case SCI_LEGEND:
1276     case SCI_ARC:
1277     case SCI_SEGS:
1278     case SCI_FEC:
1279     case SCI_GRAYPLOT:
1280     case SCI_POLYLINE:
1281     case SCI_RECTANGLE:
1282     case SCI_SURFACE:
1283     case SCI_AXES:
1284     case SCI_AGREG:
1285     case SCI_LABEL: /* F.Leray 28.05.04 */
1286     case SCI_UIMENU:
1287     default:
1288         printSetGetErrorMessage("auto_clear");
1289         return FALSE;
1290         break;
1291     }
1292     return FALSE;
1293 }
1294
1295
1296 /**sciGetAutoScale
1297 * Returns the mode of the autoscaling
1298 */
1299 BOOL
1300 sciGetAutoScale (sciPointObj * pobj)
1301 {
1302     switch (sciGetEntityType (pobj))
1303     {
1304     case SCI_FIGURE:
1305         return (sciGetGraphicMode (pobj))->autoscaling;
1306         break;
1307     case SCI_SUBWIN:
1308         return (sciGetGraphicMode (pobj))->autoscaling;
1309         break;
1310     case SCI_TEXT:
1311     case SCI_LEGEND:
1312     case SCI_ARC:
1313     case SCI_SEGS:
1314     case SCI_FEC:
1315     case SCI_GRAYPLOT:
1316     case SCI_POLYLINE:
1317     case SCI_RECTANGLE:
1318     case SCI_SURFACE:
1319     case SCI_AXES:
1320     case SCI_AGREG:
1321     case SCI_LABEL: /* F.Leray 28.05.04 */
1322     case SCI_UIMENU:
1323     default:
1324         printSetGetErrorMessage("auto_scale");
1325         return FALSE;
1326         break;
1327     }
1328     return FALSE;
1329 }
1330
1331
1332 /**sciGetZooming
1333 * Returns the zooming state of the object is it or not zoomed.
1334 */
1335 BOOL
1336 sciGetZooming (sciPointObj * pobj)
1337 {
1338     switch (sciGetEntityType (pobj))
1339     {
1340     case SCI_FIGURE:
1341         return (sciGetGraphicMode (pobj))->zooming;
1342         break;
1343     case SCI_SUBWIN:
1344         /* the value is inherited by the parent */
1345         return (sciGetGraphicMode (pobj))->zooming;
1346         break;
1347     case SCI_TEXT:
1348     case SCI_LEGEND:
1349     case SCI_ARC:
1350     case SCI_SEGS:
1351     case SCI_FEC:
1352     case SCI_GRAYPLOT:
1353     case SCI_POLYLINE:
1354     case SCI_RECTANGLE:
1355     case SCI_SURFACE:
1356     case SCI_AXES:
1357     case SCI_AGREG:
1358     case SCI_UIMENU:
1359     case SCI_LABEL: /* F.Leray 28.05.04 */
1360     default:
1361         printSetGetErrorMessage("zoom");
1362         return FALSE;
1363         break;
1364     }
1365     return FALSE;
1366 }
1367
1368
1369 /**
1370 * To know wether an object will be displayed on the screen or not.
1371 * Because if one of its parent is not visible then it won't be displayed.
1372 */
1373 BOOL
1374 sciGetRealVisibility (sciPointObj * pobj)
1375 {
1376
1377     if ( pobj == NULL )
1378     {
1379         return FALSE ;
1380     }
1381
1382     if ( sciGetEntityType( pobj ) == SCI_FIGURE )
1383     {
1384         return sciGetVisibility( pobj ) ;
1385     }
1386
1387     if ( !sciGetVisibility( pobj ) )
1388     {
1389         return FALSE ;
1390     }
1391
1392     return sciGetRealVisibility( sciGetParent( pobj ) ) ;
1393
1394 }
1395
1396 /**sciGetVisibility*/
1397 BOOL
1398 sciGetVisibility (sciPointObj * pobj)
1399 {
1400     int visible = 0;
1401     int* piVisible = &visible;
1402     getGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, jni_bool, &piVisible);
1403
1404     return visible;
1405 }
1406
1407
1408
1409 /**sciGetResize (replace sciGetwresize()in the next version)
1410 * Returns if this object is in autoresizing mode (when the window is resized by user)
1411 * @param sciPointObj * pobj: the pointer to the entity
1412 * @return TRUE if yes, FALSE if no
1413 */
1414 BOOL
1415 sciGetResize (sciPointObj * pobj)
1416 {
1417     switch (sciGetEntityType (pobj))
1418     {
1419     case SCI_FIGURE:
1420         if (isFigureModel(pobj->UID))
1421         {
1422             return pFIGURE_FEATURE(pobj)->pModelData->autoResizeMode;
1423         }
1424         else
1425         {
1426             return sciGetJavaAutoResizeMode(pobj);
1427         }
1428         break;
1429     case SCI_SUBWIN:
1430         /* the value is inhirated by the parent */
1431         return sciGetResize (sciGetParent (pobj));
1432         break;
1433     case SCI_TEXT:
1434     case SCI_LEGEND:
1435     case SCI_ARC:
1436     case SCI_SEGS:
1437     case SCI_FEC:
1438     case SCI_GRAYPLOT:
1439     case SCI_POLYLINE:
1440     case SCI_RECTANGLE:
1441     case SCI_SURFACE:
1442     case SCI_AXES:
1443     case SCI_AGREG:
1444     case SCI_LABEL: /* F.Leray 28.05.04 */
1445     case SCI_UIMENU:
1446     default:
1447         printSetGetErrorMessage("auto_resize");
1448         return FALSE;
1449         break;
1450     }
1451     return FALSE;
1452 }
1453
1454
1455 /**sciGetName
1456 * Returns the name of the Figure or SubWindow
1457 * @param sciPointObj * pobj: the pointer to the entity
1458 * @return the pointer to the char name
1459 */
1460 char *
1461 sciGetName (sciPointObj * pobj)
1462 {
1463     switch (sciGetEntityType (pobj))
1464     {
1465     case SCI_FIGURE:
1466         return pFIGURE_FEATURE (pobj)->name;
1467         break;
1468     case SCI_SUBWIN:
1469     case SCI_AGREG:
1470     default:
1471         printSetGetErrorMessage("figure_name");
1472         return NULL;
1473         break;
1474     }
1475 }
1476
1477 /**sciGetNum
1478 * Returns the number of the Figure.
1479 * @param sciPointObj * pobj: the pointer to the entity
1480 * @return the number of the windows contening this entity
1481 */
1482 int
1483 sciGetNum (sciPointObj * pobj)
1484 {
1485     int iFigureId = 0;
1486     int* piFigureId = &iFigureId;
1487
1488     getGraphicObjectProperty(pobj->UID, __GO_ID__, jni_int, &piFigureId);
1489
1490     if (piFigureId == NULL)
1491     {
1492         printSetGetErrorMessage("figure_id");
1493         return -1;
1494     }
1495
1496     return iFigureId;
1497
1498     /*
1499      * Deactivated for now.
1500      * The SUBWIN (Axes) case must be taken into account.
1501      * To be implemented using the MVC framework.
1502      */
1503 #if 0
1504     switch (sciGetEntityType (pobj))
1505     {
1506     case SCI_FIGURE:
1507         return pFIGURE_FEATURE (pobj)->number;
1508         break;
1509     case SCI_SUBWIN:
1510         return sciGetNum (sciGetParent(pobj));
1511         break;
1512     case SCI_AGREG:
1513     default:
1514         printSetGetErrorMessage("figure_id");
1515         return -1;
1516         break;
1517     }
1518 #endif
1519 }
1520
1521
1522 /**sciGetWidth
1523 * Returns the width in pixel of the figure or subwin
1524 * @param sciPointObj * pobj: the pointer to the entity
1525 * @return the width of the dimension of the window or figure
1526 * (the visibility dimension) in pixel dimension
1527 */
1528 int sciGetWidth (sciPointObj * pobj)
1529 {
1530     switch (sciGetEntityType (pobj))
1531     {
1532     case SCI_FIGURE:
1533         if ( pobj == getFigureModel() )
1534         {
1535             return pFIGURE_FEATURE(pobj)->pModelData->figureWidth;
1536         }
1537         else
1538         {
1539             int size[2] ;
1540             sciGetJavaFigureSize(pobj, size);
1541             return size[0];
1542         }
1543         break;
1544     default:
1545         printSetGetErrorMessage("width");
1546         return -1;
1547         break;
1548     }
1549 }
1550
1551
1552 /**sciGetHeight
1553 * Returns the height in pixel of the figure or subwin
1554 * @param sciPointObj * pobj: the pointer to the entity
1555 * @return the height of the dimension of the window or figure (the visibility dimension) in pixel dimension
1556 */
1557 int sciGetHeight (sciPointObj * pobj)
1558 {
1559     switch (sciGetEntityType (pobj))
1560     {
1561     case SCI_FIGURE:
1562         if ( pobj == getFigureModel() )
1563         {
1564             return pFIGURE_FEATURE(pobj)->pModelData->figureHeight;
1565         }
1566         else
1567         {
1568             int size[2] ;
1569             sciGetJavaFigureSize(pobj, size);
1570             return size[1];
1571         }
1572         break;
1573     default:
1574         printSetGetErrorMessage("height");
1575         return -1;
1576         break;
1577     }
1578 }
1579
1580 /**sciGetDim
1581 * Gets the dimension of the Figure or Subwin
1582 * @param sciPointObj * pobj: the pointer to the entity
1583 * @param int *pwidth: the return width of the window dimension
1584 * @param int *pheight: the return height of the window dimension
1585 */
1586 void sciGetDim( sciPointObj * pobj, int * pWidth, int * pHeight )
1587 {
1588     switch (sciGetEntityType (pobj))
1589     {
1590     case SCI_FIGURE:
1591         if ( pobj == getFigureModel() )
1592         {
1593             *pWidth  = pFIGURE_FEATURE(pobj)->pModelData->figureWidth ;
1594             *pHeight = pFIGURE_FEATURE(pobj)->pModelData->figureHeight;
1595         }
1596         else
1597         {
1598             int size[2] ;
1599             sciGetJavaFigureSize(pobj, size);
1600             *pWidth = size[0] ;
1601             *pHeight = size[1] ;
1602         }
1603         break;
1604     default:
1605         printSetGetErrorMessage("size");
1606         break;
1607     }
1608 }
1609
1610 /**
1611 * Get the size of the window enclosing a figure object
1612 */
1613 int sciGetWindowWidth(sciPointObj * pObj)
1614 {
1615     switch(sciGetEntityType(pObj))
1616     {
1617     case SCI_FIGURE:
1618         if ( pObj == getFigureModel() )
1619         {
1620             return pFIGURE_FEATURE(pObj)->pModelData->windowWidth ;
1621         }
1622         else
1623         {
1624             int size[2] ;
1625             sciGetJavaWindowSize(pObj, size) ;
1626             return size[0] ;
1627         }
1628         break;
1629     default:
1630         printSetGetErrorMessage("figure_size");
1631         break;
1632     }
1633     return -1;
1634 }
1635
1636
1637 int sciGetWindowHeight(sciPointObj * pObj)
1638 {
1639     switch(sciGetEntityType(pObj))
1640     {
1641     case SCI_FIGURE:
1642         if ( pObj == getFigureModel() )
1643         {
1644             return pFIGURE_FEATURE(pObj)->pModelData->windowHeight ;
1645         }
1646         else
1647         {
1648             int size[2] ;
1649             sciGetJavaWindowSize(pObj, size) ;
1650             return size[1] ;
1651         }
1652         break;
1653     default:
1654         printSetGetErrorMessage("figure_size");
1655         break;
1656     }
1657     return -1;
1658 }
1659
1660
1661 /**sciIsExistingSubWin
1662 * Determines if this SubWindow is an existing one in the current SCI_FIGURE
1663 * in association with the wrect and frect....
1664 * @param WRect: Window rectangle dimension in double,
1665 * @param FRect: window user's scale dimension in double,
1666 * @param logscale: flag for logarithmic window
1667 * @return the pointer to the existing SubWindow, or Null if no one is existing
1668 */
1669 sciPointObj *
1670 sciIsExistingSubWin (double WRect[4])
1671 {
1672
1673 // ???
1674 #if 0
1675     sciPointObj *pparentfigure;
1676     sciSons *psonstmp;
1677
1678     double WRectTmp[4];
1679     int i;
1680
1681
1682     /* Initialisation de WRectTmp a 0*/
1683     for(i=0;i<4;i++)
1684     {
1685         WRectTmp[i] = 0.0;
1686     }
1687
1688     pparentfigure = (sciPointObj *)sciGetCurrentFigure();
1689     if (pparentfigure == NULL)
1690     {
1691         return NULL;
1692     }
1693
1694     /**  15/03/2002 **/
1695     if ((WRect[0] == 0.)&&(WRect[1] == 0.)&&(WRect[2] == 1.)&&(WRect[3] == 1.))
1696     {
1697         /* return the last subwindow */
1698         sciSons * curSon = sciGetLastSons(pparentfigure);
1699         while (sciGetEntityType(curSon->pointobj) != SCI_SUBWIN)
1700         {
1701             curSon = curSon->pprev;
1702         }
1703         return curSon->pointobj;
1704     }
1705
1706     psonstmp = sciGetSons (pparentfigure);
1707     while (psonstmp != NULL)
1708     {
1709         sciPointObj * curObj = psonstmp->pointobj;
1710         if (sciGetEntityType (curObj) == SCI_SUBWIN)
1711         {
1712             WRectTmp[0] = pSUBWIN_FEATURE (curObj)->WRect[0];
1713             WRectTmp[1] = pSUBWIN_FEATURE (curObj)->WRect[1];
1714             WRectTmp[2] = pSUBWIN_FEATURE (curObj)->WRect[2];
1715             WRectTmp[3] = pSUBWIN_FEATURE (curObj)->WRect[3];
1716
1717             if (   (Abs(WRectTmp[0] - WRect[0]) < 1e-8)
1718                 && (Abs(WRectTmp[1] - WRect[1]) < 1e-8)
1719                 && (Abs(WRectTmp[2] - WRect[2]) < 1e-8)
1720                 && (Abs(WRectTmp[3] - WRect[3]) < 1e-8))
1721             {
1722                 /* subwin found */
1723                 return curObj;
1724             }
1725         }
1726         psonstmp = psonstmp->pnext;
1727     }
1728
1729 #endif
1730     return NULL;
1731 }
1732
1733 /*--------------------------------------------------------------------------*/
1734
1735
1736 /**sciGetPoint
1737 * returns pointer to the points of the entity, and a pointer to the number of points. This function allocates memory for the tab of point, so after using the tab don't forget to free it
1738 */
1739
1740 /**MAJ pour le 3D DJ.Abdemouche 2003**/
1741 double *sciGetPoint(char * pthis, int *numrow, int *numcol)
1742 {
1743     char* type;
1744     double *tab;
1745     int i,k;
1746
1747     getGraphicObjectProperty(pthis, __GO_TYPE__, jni_string, &type);
1748
1749     /*
1750      * Object type determined by string comparisons
1751      * Required as we have no better way to do this for the moment
1752      */
1753     if (strcmp(type, __GO_FIGURE__) == 0)
1754     {
1755         int* figurePosition;
1756         int* axesSize;
1757
1758         *numrow = 2;
1759         *numcol = 2;
1760         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1761         {
1762             *numrow = -1;
1763             *numcol = -1;
1764             return NULL;
1765         }
1766
1767         getGraphicObjectProperty(pthis, __GO_POSITION__, jni_int_vector, &figurePosition);
1768         getGraphicObjectProperty(pthis, __GO_AXES_SIZE__, jni_int_vector, &axesSize);
1769
1770         tab[0] = (double) figurePosition[0];
1771         tab[1] = (double) figurePosition[1];
1772         tab[2] = (double) axesSize[0];
1773         tab[3] = (double) axesSize[1];
1774
1775         return tab;
1776     }
1777     else if (strcmp(type, __GO_POLYLINE__) == 0)
1778     {
1779         char* parentAxes;
1780         double* dataX = NULL;
1781         double* dataY = NULL;
1782         double* dataZ = NULL;
1783         int iTmp = 0;
1784         int* piTmp = &iTmp;
1785         int iView =0;
1786         int *piView = &iView;
1787
1788         /*
1789          * Testing whether data properties exist for this object
1790          * is currently done only for this property. The type comparison already
1791          * ensures that this is the case, though doing so is awkward.
1792          */
1793         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_ELEMENTS__, jni_int, &piTmp);
1794
1795         if (piTmp == NULL)
1796         {
1797             *numrow = -2;
1798             *numcol = -2;
1799             return NULL;
1800         }
1801
1802         *numrow = iTmp;
1803
1804         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z_COORDINATES_SET__, jni_int, &piTmp);
1805
1806         if (iTmp)
1807         {
1808             *numcol = 3;
1809         }
1810         else
1811         {
1812             *numcol = 2;
1813         }
1814
1815         if ( (*numrow)*(*numcol) == 0 )
1816         {
1817             /* empty data, no warnings */
1818             *numrow = 0;
1819             *numcol = 0;
1820             return NULL;
1821         }
1822
1823         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1824         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1825
1826         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, jni_double_vector, &dataX);
1827         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, jni_double_vector, &dataY);
1828
1829         if (*numcol == 2 && iView)
1830         {
1831             *numcol = (*numcol)+1; /* colonne de 0. a prendre en compte / afficher => numcol+1*/
1832             if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1833             {
1834                 *numrow = -1;
1835                 *numcol = -1;
1836                 return NULL;
1837             }
1838
1839             for ( i = 0 ; i < *numrow ; i++ )
1840             {
1841                 tab[i] = dataX[i];
1842                 tab[*numrow+i]= dataY[i];
1843                 tab[(2*(*numrow))+i]= 0.;
1844             }
1845         }
1846         else
1847         {
1848             if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1849             {
1850                 *numrow = -1;
1851                 *numcol = -1;
1852                 return NULL;
1853             }
1854
1855             if (*numcol == 3)
1856             {
1857                 getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, jni_double_vector, &dataZ);
1858             }
1859
1860             for ( i = 0 ; i < *numrow ; i++ )
1861             {
1862                 tab[i] = dataX[i];
1863                 tab[*numrow+i]= dataY[i];
1864                 if (*numcol== 3)
1865                 {
1866                     tab[(2*(*numrow))+i] = dataZ[i];
1867                 }
1868             }
1869
1870         }
1871         return tab;
1872     }
1873     else if (strcmp(type, __GO_RECTANGLE__) == 0)
1874     {
1875         char* parentAxes;
1876         double* upperLeftPoint;
1877         double* tmpDouble;
1878         double width = 0.0;
1879         double *pdblWidth = &width;
1880         double height = 0.0;
1881         double *pdblHeight = &height;
1882         int* tmp;
1883         int iView = 0;
1884         int *piView = &iView;
1885
1886         *numrow = 1;
1887
1888         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1889         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1890
1891         *numcol = iView ? 5: 4;
1892
1893         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1894         {
1895             *numrow = -1;
1896             *numcol = -1;
1897             return NULL;
1898         }
1899
1900         getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &upperLeftPoint);
1901
1902         getGraphicObjectProperty(pthis, __GO_WIDTH__, jni_double, &pdblWidth);
1903         getGraphicObjectProperty(pthis, __GO_HEIGHT__, jni_double, &pdblHeight);
1904
1905         tab[0] = upperLeftPoint[0];
1906         tab[1] = upperLeftPoint[1];
1907
1908         if (iView)
1909         {
1910             tab[2] = upperLeftPoint[2];
1911             tab[3] = width;
1912             tab[4] = height;
1913         }
1914         else
1915         {
1916             tab[2] = width;
1917             tab[3] = height;
1918         }
1919         return (double*)tab;
1920     }
1921     else if (strcmp(type, __GO_ARC__) == 0)
1922     {
1923         char* parentAxes;
1924         double* upperLeftPoint;
1925         double* tmpDouble;
1926         double width = 0.0;
1927         double *pdblWidth = &width;
1928
1929         double height;
1930         double *pdblHeight = &height;
1931
1932         double startAngle;
1933         double *pdblStartAngle = &startAngle;
1934         double endAngle;
1935         double *pdblEndAngle = &endAngle;
1936         int* tmp;
1937         int view = 0;
1938         int *piView = &view;
1939
1940         *numrow = 1;
1941
1942         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1943         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1944
1945         *numcol = view ? 7: 6;
1946
1947         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1948         {
1949             *numrow = -1;
1950             *numcol = -1;
1951             return NULL;
1952         }
1953
1954         getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &upperLeftPoint);
1955
1956         getGraphicObjectProperty(pthis, __GO_WIDTH__, jni_double, &pdblWidth);
1957         getGraphicObjectProperty(pthis, __GO_HEIGHT__, jni_double, &pdblHeight);
1958
1959         getGraphicObjectProperty(pthis, __GO_START_ANGLE__, jni_double, &pdblStartAngle);
1960         getGraphicObjectProperty(pthis, __GO_END_ANGLE__, jni_double, &pdblEndAngle);
1961
1962         tab[0] = upperLeftPoint[0];
1963         tab[1] = upperLeftPoint[1];
1964
1965         if (view)
1966         {
1967             tab[2] = upperLeftPoint[2];
1968             tab[3] = width;
1969             tab[4] = height;
1970             tab[5] = RAD2DEG(startAngle);
1971             tab[6] = RAD2DEG(endAngle);
1972         }
1973         else
1974         {
1975             tab[2] = width;
1976             tab[3] = height;
1977             tab[4] = RAD2DEG(startAngle);
1978             tab[5] = RAD2DEG(endAngle);
1979         }
1980
1981         return (double*)tab;
1982     }
1983     else if (strcmp(type, __GO_COMPOUND__) == 0)
1984     {
1985         return (double*)NULL;
1986     }
1987     else if (strcmp(type, __GO_TEXT__) == 0)
1988     {
1989         char* parentAxes;
1990         double* textPosition;
1991         int iView = 0;
1992         int* piView = &iView;
1993
1994         *numrow = 1;
1995
1996         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1997         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1998
1999         *numcol = iView ? 3: 2;
2000
2001         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
2002         {
2003             *numrow = -1;
2004             *numcol = -1;
2005             return NULL;
2006         }
2007
2008         getGraphicObjectProperty(pthis, __GO_POSITION__, jni_double_vector, &textPosition);
2009
2010         tab[0] = textPosition[0];
2011         tab[1] = textPosition[1];
2012
2013         if (iView)
2014         {
2015             tab[2] = textPosition[2];
2016         }
2017
2018         return (double*)tab;
2019     }
2020     else if (strcmp(type, __GO_SEGS__) == 0)
2021     {
2022         int iView = 0;
2023         int* piView = &iView;
2024         int iNumArrows = 0;
2025         int* piNumArrows = &iNumArrows;
2026         char* parentAxes;
2027         double* arrowBases;
2028         double* arrowDirections;
2029
2030         getGraphicObjectProperty(pthis, __GO_NUMBER_ARROWS__, jni_int, &piNumArrows);
2031         *numrow = iNumArrows;
2032
2033         /* only two coordinates are displayed if the axe is in 2d
2034         and the z coordinates has never been modified */
2035
2036         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
2037
2038         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
2039
2040         if (iView)
2041         {
2042             *numcol = 3;
2043         }
2044         else
2045         {
2046             *numcol = 2;
2047         }
2048
2049         if ((tab = CALLOC(2*(*numrow)*(*numcol),sizeof(double))) == NULL)
2050         {
2051             *numrow = -1;
2052             *numcol = -1;
2053             return NULL;
2054         }
2055
2056         getGraphicObjectProperty(pthis, __GO_BASE__, jni_double_vector, &arrowBases);
2057         getGraphicObjectProperty(pthis, __GO_DIRECTION__, jni_double_vector, &arrowDirections);
2058
2059         for (i = 0; i < *numrow; i++)
2060         {
2061             tab[2*i] = arrowBases[3*i];
2062             tab[2*i+1] = arrowDirections[3*i];
2063             tab[2*(*numrow)+2*i] = arrowBases[3*i+1];
2064             tab[2*(*numrow)+2*i+1] = arrowDirections[3*i+1];
2065
2066             if (iView)
2067             {
2068                 tab[4*(*numrow)+2*i] = arrowBases[3*i+2];
2069                 tab[4*(*numrow)+2*i+1] = arrowDirections[3*i+2];
2070             }
2071         }
2072
2073         /* There are twice as many points as arrows (2 endpoints) */
2074         *numrow = 2*(*numrow);
2075
2076         return (double*)tab;
2077     }
2078     else if (strcmp(type, __GO_FAC3D__) == 0)
2079     {
2080         *numrow = -1;
2081         *numcol = -1;
2082         return (double*) NULL;
2083     }
2084     else if (strcmp(type, __GO_PLOT3D__) == 0)
2085     {
2086         *numrow = -1;
2087         *numcol = -1;
2088         return (double*) NULL;
2089     }
2090     else if (strcmp(type, __GO_MATPLOT__) == 0)
2091     {
2092         int* tmp;
2093         int nx = 0;
2094         int *piNx = &nx;
2095         int ny = 0;
2096         int *piNy = &ny;
2097         double* data;
2098
2099         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_X__, jni_int, &piNx);
2100
2101         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_Y__, jni_int, &piNy);
2102
2103         /* The z data matrix has (ny-1) rows and (nx-1) cols */
2104         nx = nx - 1;
2105         ny = ny - 1;
2106
2107         *numrow = ny;
2108         *numcol = nx;
2109
2110         if ((tab = CALLOC(nx*ny,sizeof(double))) == NULL)
2111         {
2112             *numrow = -1;
2113             *numcol = -1;
2114             return (double*)NULL;
2115         }
2116
2117         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, jni_double_vector, &data);
2118
2119         for (i=0; i < nx*ny; i++)
2120         {
2121             tab[i] = data[i];
2122         }
2123
2124         return (double*)tab;
2125     }
2126     else if (strcmp(type, __GO_FEC__) == 0)
2127     {
2128         double* coordinates;
2129         double* values;
2130         int iTmp = 0;
2131         int* piTmp = &iTmp;
2132
2133         *numcol = 3;
2134
2135         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_VERTICES__, jni_int, &piTmp);
2136         *numrow = iTmp;
2137
2138         if ((tab = CALLOC(*numrow * 3,sizeof(double))) == NULL)
2139         {
2140             *numrow = -1;
2141             *numcol = -1;
2142             return (double*)NULL;
2143         }
2144
2145         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_COORDINATES__, jni_double_vector, &coordinates);
2146         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_VALUES__, jni_double_vector, &values);
2147
2148         for (i=0;i < *numrow;i++)
2149         {
2150             tab[i] = coordinates[3*i];
2151             tab[*numrow+i] = coordinates[3*i+1];
2152             tab[*numrow*2+i] = values[i];
2153
2154         }
2155
2156         return (double*)tab;
2157     }
2158     else if (strcmp(type, __GO_LEGEND__) == 0)
2159     {
2160         *numrow = -2;
2161         *numcol = -2;
2162         return (double*)NULL;
2163     }
2164     else if (strcmp(type, __GO_AXES__) == 0)
2165     {
2166         *numrow = -2;
2167         *numcol = -2;
2168         return (double*)NULL;
2169     }
2170     /* F.Leray 28.05.04 */
2171     else if (strcmp(type, __GO_LABEL__) == 0)
2172     {
2173         *numrow = -2;
2174         *numcol = -2;
2175         return (double*)NULL;
2176     }
2177     else
2178     {
2179         *numrow = -2;
2180         *numcol = -2;
2181         return (double*)NULL;
2182     }
2183
2184     /*
2185      * Deactivated for now
2186      * Same as the else condition
2187      */
2188 #if 0
2189     case SCI_UIMENU:
2190 #endif
2191     return (double*)NULL;
2192 }
2193
2194
2195 BOOL
2196 sciGetdrawmode (sciPointObj *pobj)
2197 {
2198     static sciPointObj *subwin;
2199
2200     subwin= (sciPointObj *) sciGetParentSubwin (pobj);
2201     if  (subwin != (sciPointObj *) NULL)
2202         return pSUBWIN_FEATURE(subwin)->visible ;
2203     return FALSE;
2204 }
2205
2206 /**sciGetAxes
2207 * Gets SUBWIN of this Scilab graphic figure
2208 * @author Djalel ABDEMOUCHE
2209 */
2210 sciPointObj *
2211 sciGetAxes (sciPointObj *pparentfigure,sciPointObj *psubwin)
2212 {
2213     sciSons *psonstmp;
2214
2215     psonstmp = sciGetSons (pparentfigure);
2216
2217
2218     if (psonstmp != (sciSons *) NULL)
2219     {
2220         /* tant que le fils ne corespond pas a l'entite */
2221         while ((psonstmp->pnext  != (sciSons *) NULL)
2222             && (sciGetEntityType (psonstmp->pointobj) != SCI_SUBWIN))
2223             psonstmp = psonstmp->pnext;
2224
2225         if  (psonstmp->pnext  == (sciSons *) NULL)
2226             return (sciPointObj *) NULL;
2227         else
2228             if (sciGetEntityType (psonstmp->pointobj) == SCI_SUBWIN)
2229                 return (sciPointObj *)psonstmp->pointobj;
2230             else
2231                 return (sciPointObj *) NULL; /* added SS ????*/
2232     }
2233     else
2234         return (sciPointObj *) NULL;
2235 }
2236
2237 /**sciGetPointerToToUserData
2238 * Returns the pointer to the user_data and size_of_user_data fields associated with
2239 the pobj object
2240 */
2241 void sciGetPointerToUserData (sciPointObj * pobj,int ***user_data_ptr, int **size_ptr)
2242 {
2243
2244     /* perhaps is it necessary to cast the returns value with void* type ! */
2245     switch (sciGetEntityType (pobj))
2246     {
2247     case SCI_FIGURE:
2248         *user_data_ptr = &(((sciFigure *) pFIGURE_FEATURE (pobj))->user_data);
2249         *size_ptr=&(((sciFigure *) pFIGURE_FEATURE (pobj))->size_of_user_data);
2250         break;
2251     case SCI_SUBWIN:
2252         *user_data_ptr = &(((sciSubWindow *) pSUBWIN_FEATURE (pobj))->user_data);
2253         *size_ptr =  &(((sciSubWindow *) pSUBWIN_FEATURE (pobj))->size_of_user_data);
2254         break;
2255     case SCI_TEXT:
2256         *user_data_ptr = &(((sciText *) pTEXT_FEATURE (pobj))->user_data);
2257         *size_ptr =  &(((sciText *) pTEXT_FEATURE (pobj))->size_of_user_data);
2258         break;
2259     case SCI_LEGEND:
2260         *user_data_ptr = &(((sciLegend *) pLEGEND_FEATURE (pobj))->user_data);
2261         *size_ptr =  &(((sciLegend *) pLEGEND_FEATURE (pobj))->size_of_user_data);
2262         break;
2263     case SCI_ARC:
2264         *user_data_ptr = &(((sciArc *) pARC_FEATURE (pobj))->user_data);
2265         *size_ptr = &(((sciArc *) pARC_FEATURE (pobj))->size_of_user_data);
2266         break;
2267     case SCI_POLYLINE:
2268         *user_data_ptr = &(((sciPolyline *) pPOLYLINE_FEATURE (pobj))->user_data);
2269         *size_ptr =  &(((sciPolyline *) pPOLYLINE_FEATURE (pobj))->size_of_user_data);
2270         break;
2271     case SCI_SEGS:
2272         *user_data_ptr = &(((sciSegs *) pSEGS_FEATURE (pobj))->user_data);
2273         *size_ptr = &(((sciSegs *) pSEGS_FEATURE (pobj))->size_of_user_data );
2274         break;
2275     case SCI_FEC:
2276         *user_data_ptr = &(((sciFec *) pFEC_FEATURE (pobj))->user_data);
2277         *size_ptr =  &(((sciFec *) pFEC_FEATURE (pobj))->size_of_user_data) ;
2278         break;
2279     case SCI_GRAYPLOT:
2280         *user_data_ptr = &(((sciGrayplot *) pGRAYPLOT_FEATURE (pobj))->user_data);
2281         *size_ptr =  &(((sciGrayplot *) pGRAYPLOT_FEATURE (pobj))->size_of_user_data);
2282         break;
2283     case SCI_RECTANGLE:
2284         *user_data_ptr = &(((sciRectangle *) pRECTANGLE_FEATURE (pobj))->user_data);
2285         *size_ptr =  &(((sciRectangle *) pRECTANGLE_FEATURE (pobj))->size_of_user_data);
2286         break;
2287     case SCI_SURFACE:
2288         *user_data_ptr = &(((sciSurface *) pSURFACE_FEATURE (pobj))->user_data);
2289         *size_ptr =  &(((sciSurface *) pSURFACE_FEATURE (pobj))->size_of_user_data);
2290         break;
2291     case SCI_AXES:
2292         *user_data_ptr = &(((sciAxes *) pAXES_FEATURE (pobj))->user_data);
2293         *size_ptr =  &(((sciAxes *) pAXES_FEATURE (pobj))->size_of_user_data);
2294         break;
2295     case SCI_AGREG:
2296         *user_data_ptr = &(((sciAgreg *) pAGREG_FEATURE (pobj))->user_data);
2297         *size_ptr =  &(((sciAgreg *) pAGREG_FEATURE (pobj))->size_of_user_data);
2298         break;
2299     case SCI_LABEL:
2300         sciGetPointerToUserData ( pLABEL_FEATURE(pobj)->text, user_data_ptr, size_ptr ) ;
2301         break;
2302     case SCI_UIMENU:
2303         *user_data_ptr = &(pUIMENU_FEATURE (pobj)->user_data);
2304         *size_ptr=&(pUIMENU_FEATURE (pobj)->size_of_user_data);
2305         break;
2306     case SCI_UICONTROL:
2307         *user_data_ptr = &(pUICONTROL_FEATURE (pobj)->user_data);
2308         *size_ptr=&(pUICONTROL_FEATURE (pobj)->size_of_user_data);
2309         break;
2310     default:
2311         *user_data_ptr = (int **)NULL;
2312         *size_ptr =   (int *)NULL;
2313         break;
2314     }
2315 }
2316
2317
2318 /**
2319 * Don't use this ugly function !!!! (Jb Silvy)
2320 * 130 strcmp to know the type of a parameter
2321 */
2322 int sciType (char *marker,sciPointObj * pobj)
2323 {
2324     if      (strcmp(marker,"arrow_size_factor") == 0) { return sci_matrix;}
2325     else if (strcmp(marker,"x_shift") == 0) { return sci_matrix;}
2326     else if (strcmp(marker,"y_shift") == 0) { return sci_matrix;}
2327     else if (strcmp(marker,"z_shift") == 0) { return sci_matrix;}
2328     else if (strcmp(marker,"bar_width") == 0) { return sci_matrix;}
2329     else if (strcmp(marker,"closed") == 0) { return sci_strings;}
2330     else if (strcmp(marker,"label") == 0) { return sci_strings;}
2331     else if (strcmp(marker,"callback") == 0) { return sci_strings;}
2332     else if (strcmp(marker,"background") == 0) { return sci_matrix;}
2333     else if (strcmp(marker,"position") == 0) {return sci_matrix;}
2334     else if (strcmp(marker,"auto_position") == 0)   {return sci_strings;}
2335     else if (strcmp(marker,"auto_rotation") == 0)   {return sci_strings;}
2336     else if (strcmp(marker,"interp_color_vector") == 0) {return sci_matrix;}
2337     else if (strcmp(marker,"interp_color_mode") == 0) {return sci_strings;}
2338     else if (strcmp(marker,"foreground") == 0) {return sci_matrix;}
2339     else if (strcmp(marker,"thickness") == 0)   {return sci_matrix;}
2340     else if (strcmp(marker,"line_style") == 0) {return sci_matrix;}
2341     else if (strcmp(marker,"line_mode") == 0) {return sci_strings;}
2342     else if (strcmp(marker,"fill_mode") == 0) {return sci_strings;}
2343     else if (strcmp(marker,"surface_mode") == 0) {return sci_strings;}
2344     else if (strcmp(marker,"mark_style") == 0) {return sci_matrix;}
2345     else if (strcmp(marker,"mark_size") == 0) {return sci_matrix;}
2346     else if (strcmp(marker,"mark_size_unit") == 0) {return sci_strings;}
2347     else if (strcmp(marker,"mark_mode") == 0)   {return sci_strings;}
2348     else if (strcmp(marker,"mark_foreground") == 0)   {return sci_matrix;}
2349     else if (strcmp(marker,"mark_background") == 0)   {return sci_matrix;}
2350     else if (strcmp(marker,"figure_position") == 0) {return sci_matrix;}
2351     else if (strcmp(marker,"axes_size") == 0)   {return sci_matrix;}
2352     else if (strcmp(marker,"axes_visible") == 0)   {return sci_strings;}
2353     else if (strcmp(marker,"hiddencolor") == 0)   {return 1;}/* DJ.A 2003 */
2354     else if (strcmp(marker,"isoview") == 0)   {return sci_strings;}/**DJ.Abdemouche 2003**/
2355     else if (strcmp(marker,"view") == 0)   {return sci_strings;}/**DJ.Abdemouche 2003**/
2356     else if (strcmp(marker,"figure_size") == 0){return sci_matrix;}
2357     else if (strcmp(marker,"figure_id") == 0)   {return sci_matrix;}
2358     else if (strcmp(marker,"figure_name") == 0){return sci_strings;}
2359     else if (strcmp(marker,"figures_id") == 0)   {return sci_matrix;}
2360     else if (strcmp(marker,"pixmap") == 0)   {return sci_strings;}/*Ajout A.Djalel*/
2361     else if (strcmp(marker,"polyline_style") == 0){return sci_matrix;}
2362     else if (strcmp(marker,"font_size") == 0)   {return sci_matrix;}
2363     else if (strcmp(marker,"font_angle") == 0) {return sci_matrix;}
2364     else if (strcmp(marker,"font_foreground") == 0){return sci_matrix;}
2365     else if (strcmp(marker,"font_color") == 0)   {return sci_matrix;} /* F.Leray 09.04.04 : Adding to support font_color user interface */
2366     else if (strcmp(marker,"font_style") == 0) {return sci_matrix;}
2367     else if (strcmp(marker,"font_name") == 0)   {return sci_strings;}
2368     else if (strcmp(marker,"textcolor"          ) == 0) {return sci_matrix;}
2369     else if (strcmp(marker,"labels_font_size"   ) == 0) {return sci_matrix;}
2370     else if (strcmp(marker,"labels_font_color"  ) == 0) {return sci_matrix;}
2371     else if (strcmp(marker,"text"               ) == 0) {return sci_strings;}
2372     else if (strcmp(marker,"text_box"           ) == 0) {return sci_matrix;}
2373     else if (strcmp(marker,"text_box_mode"      ) == 0) {return sci_strings;}
2374     else if (strcmp(marker,"old_style"          ) == 0) {return sci_strings;}
2375     else if (strcmp(marker,"figure_style"       ) == 0) {return sci_strings;}
2376     else if (strcmp(marker,"visible"            ) == 0) {return sci_strings;}
2377     else if (strcmp(marker,"auto_resize"        ) == 0) {return sci_strings;}
2378     else if (strcmp(marker,"pixel_drawing_mode" ) == 0) {return sci_strings;}
2379     else if (strcmp(marker,"default_values"     ) == 0) {return sci_matrix ;}
2380     else if (strcmp(marker,"color_map"          ) == 0) {return sci_matrix ;}
2381     else if (strcmp(marker,"x_location"         ) == 0) {return sci_strings;}
2382     else if (strcmp(marker,"y_location"         ) == 0) {return sci_strings;}
2383     else if (strcmp(marker,"tics_direction"     ) == 0) {return sci_strings;}
2384     else if (strcmp(marker,"tight_limits"       ) == 0) {return sci_strings;}
2385     else if (strcmp(marker,"box"                ) == 0) {return sci_strings;}
2386     else if (strcmp(marker,"tics_color"         ) == 0) {return sci_matrix ;}
2387     else if (strcmp(marker,"tics_textcolor"     ) == 0) {return sci_matrix ;}
2388     else if (strcmp(marker,"tics_textsize"      ) == 0) {return sci_matrix ;}
2389     else if (strcmp(marker,"xtics_coord"        ) == 0) {return sci_matrix ;}
2390     else if (strcmp(marker,"ytics_coord"        ) == 0) {return sci_matrix ;}
2391     else if (strcmp(marker,"grid"               ) == 0) {return sci_matrix ;}
2392     else if (strcmp(marker,"tics_segment"       ) == 0) {return sci_strings;}
2393     else if (strcmp(marker,"tics_style"         ) == 0) {return sci_strings;}
2394     else if (strcmp(marker,"format_n"           ) == 0) {return sci_strings;}
2395     else if (strcmp(marker,"tics_labels"        ) == 0) {return sci_strings;}
2396     else if (strcmp(marker,"sub_tics"           ) == 0) {return sci_matrix;}
2397     else if (strcmp(marker,"sub_ticks"          ) == 0) {return sci_matrix;} /* new writing F.Leray 12.10.04 to be consistent with x,y,z _ticks*/
2398     else if (strcmp(marker,"zoom_box"           ) == 0) {return sci_matrix;}
2399     else if (strcmp(marker,"zoom_state"         ) == 0) {return sci_strings;}
2400     else if (strcmp(marker,"clip_box"           ) == 0) {return sci_matrix;}
2401     else if (strcmp(marker,"clip_state"         ) == 0) {return sci_strings;}
2402     else if (strcmp(marker,"auto_clear"         ) == 0) {return sci_strings;}
2403     else if (strcmp(marker,"auto_scale"         ) == 0) {return sci_strings;}
2404     else if (strcmp(marker,"arrow_size"         ) == 0) {return sci_matrix;}
2405     else if (strcmp(marker,"segs_color"         ) == 0) {return sci_matrix;}
2406     else if (strcmp(marker,"colored"            ) == 0) {return sci_strings;}
2407     else if (strcmp(marker,"data"               ) == 0)
2408         if((sciGetEntityType(pobj) == SCI_SURFACE) ||
2409             (sciGetEntityType(pobj) == SCI_SEGS     && pSEGS_FEATURE(pobj)->ptype == 1) || /* a champ */
2410             (sciGetEntityType(pobj) == SCI_GRAYPLOT && pGRAYPLOT_FEATURE(pobj)->type == 0))    /* a grayplot (case == 0) */
2411             return sci_tlist;
2412         else
2413             return 1;
2414     else if (strcmp(marker,"hdl"                ) == 0) {return sci_matrix;}
2415     else if (strcmp(marker,"callbackmevent"     ) == 0) {return sci_matrix;}
2416     else if (strcmp(marker,"callback"           ) == 0) {return sci_strings;}
2417     else if (strcmp(marker,"log_flags"          ) == 0) {return sci_strings;}
2418     else if (strcmp(marker,"data_mapping"       ) == 0) {return sci_strings;}
2419     else if (strcmp(marker,"surface_color"      ) == 0) {return sci_matrix;}
2420     else if (strcmp(marker,"rotation_angles"    ) == 0) {return sci_matrix;}
2421     else if (strcmp(marker,"color_mode"         ) == 0) {return sci_matrix;}/*DJ.A merge*/
2422     else if (strcmp(marker,"color_flag"         ) == 0) {return sci_matrix;}
2423     else if (strcmp(marker,"cdata_mapping"      ) == 0) {return sci_strings;}
2424     else if (strcmp(marker,"axes_bounds"        ) == 0) {return sci_matrix;}
2425     else if (strcmp(marker,"data_bounds"        ) == 0) {return sci_matrix;}
2426     else if (strcmp(marker,"margins"            ) == 0) {return sci_matrix;}
2427     else if (strcmp(marker,"surface_color"      ) == 0) {return sci_matrix;}
2428     else if (strcmp(marker,"rotation_style"     ) == 0) {return sci_strings;}
2429     else if (strcmp(marker,"triangles"          ) == 0) {return sci_matrix;}
2430     else if (strcmp(marker,"z_bounds"           ) == 0) {return sci_matrix;}
2431     else if (strcmp(marker,"current_axes"       ) == 0) {return sci_handles;}
2432     else if (strcmp(marker,"current_figure"     ) == 0) {return sci_handles;}
2433     else if (strcmp(marker,"current_obj"        ) == 0) {return sci_handles;}
2434     else if (strcmp(marker,"current_entity"     ) == 0) {return sci_handles;}
2435     else if (strcmp(marker,"default_axes"       ) == 0) {return sci_handles;}/* DJ.A 08/01/04 */
2436     else if (strcmp(marker,"default_figure"     ) == 0) {return sci_handles;}/* DJ.A 08/01/04 */
2437     else if (strcmp(marker,"children"           ) == 0) {return sci_handles;}
2438     else if (strcmp(marker,"cube_scaling"       ) == 0) {return sci_strings;} /* F.Leray 22.04.04 */
2439     else if (strcmp(marker,"x_label"            ) == 0) {return sci_handles;}  /* F.Leray 27.05.04 */
2440     else if (strcmp(marker,"y_label"            ) == 0) {return sci_handles;}
2441     else if (strcmp(marker,"z_label"            ) == 0) {return sci_handles;}
2442     else if (strcmp(marker,"title"              ) == 0) {return sci_handles;}
2443     else if (strcmp(marker,"x_ticks"            ) == 0) {return sci_tlist;}
2444     else if (strcmp(marker,"y_ticks"            ) == 0) {return sci_tlist;}
2445     else if (strcmp(marker,"z_ticks"            ) == 0) {return sci_tlist;}
2446     else if (strcmp(marker,"auto_ticks"         ) == 0) {return sci_strings;}
2447     else if (strcmp(marker,"axes_reverse"       ) == 0) {return sci_strings;}
2448     else if (strcmp(marker,"immediate_drawing"  ) == 0) {return sci_strings;}
2449     else if (strcmp(marker,"handle_visible"     ) == 0) {return sci_strings;}
2450     else if (strcmp(marker,"enable"             ) == 0) {return sci_strings;}
2451     else if (strcmp(marker,"callback_type"      ) == 0) {return sci_strings;}
2452     else if (strcmp(marker,"bounding_rect"      ) == 0) {return sci_matrix;} /*JBS 16/11/05 */
2453     else if (strcmp(marker,"hidden_axis_color"  ) == 0) {return sci_matrix;} /*       03/06 */
2454     else if (strcmp(marker,"alignment"          ) == 0) {return sci_strings;} /*       05/06 */
2455     else if (strcmp(marker,"viewport"           ) == 0) {return sci_matrix;} /*       01/07 */
2456     else if (strcmp(marker,"info_message"       ) == 0) {return sci_strings;} /*       01/07 */
2457     else {return -1;}
2458 }
2459 /*-------------------------------------------------------------------------------*/
2460 /**
2461 * Return the first surface found within the descendant of the object.
2462 * @param[in] psubwin Object from which the surface will be searched.
2463 * @return The first surface object if found, NULL otherwise.
2464 */
2465 sciPointObj * sciGetSurface( sciPointObj * pObj )
2466 {
2467     sciSons * psonstmp;
2468     sciPointObj * sonSurface = NULL ;
2469
2470     psonstmp = sciGetSons( pObj ) ;
2471     while ( psonstmp != NULL )
2472     {
2473         if( sciGetEntityType( psonstmp->pointobj ) == SCI_SURFACE )
2474         {
2475             /* We found one, return it.*/
2476             return psonstmp->pointobj ;
2477         }
2478         /* check the sons of this children */
2479         sonSurface = sciGetSurface( psonstmp->pointobj ) ;
2480         if ( sonSurface != NULL )
2481         {
2482             return sonSurface ;
2483         }
2484         psonstmp = psonstmp->pnext;
2485     }
2486     /* nothing has been found */
2487     return NULL;
2488 }
2489
2490 /**sciGetOriginalSubWin
2491 * PRIVATE.
2492 * @param sciPointObj * pfigure: the pointer to the parent figure
2493 * @return the pointer of the original subwindow
2494 */
2495 sciPointObj *
2496 sciGetOriginalSubWin (sciPointObj * pfigure)
2497 {
2498     return (sciPointObj *)pFIGURE_FEATURE(pfigure)->originalsubwin0011;
2499 }
2500
2501
2502 /* get the property of the axes box */
2503 EAxesBoxType sciGetBoxType( sciPointObj * pobj )
2504 {
2505     switch (sciGetEntityType (pobj))
2506     {
2507     case SCI_SUBWIN:
2508         return pSUBWIN_FEATURE(pobj)->axes.rect ;
2509     default:
2510         printSetGetErrorMessage("box_type");
2511         return (EAxesBoxType)0 ;
2512     }
2513     return (EAxesBoxType)0;
2514 }
2515
2516
2517 /**sciGetIsBoxed
2518 * Returns the box existence
2519 */
2520 BOOL
2521 sciGetIsBoxed (sciPointObj * pobj)
2522 {
2523     switch (sciGetEntityType (pobj))
2524     {
2525     case SCI_TEXT:
2526         return pTEXT_FEATURE(pobj)->isboxed;
2527         break;
2528     case SCI_SUBWIN:
2529         return ( pSUBWIN_FEATURE(pobj)->axes.rect == BT_ON || pSUBWIN_FEATURE(pobj)->axes.rect == BT_BACK_HALF ) ;
2530     case SCI_LABEL:
2531     case SCI_POLYLINE:
2532     case SCI_RECTANGLE:
2533     case SCI_ARC:
2534     case SCI_FIGURE:
2535     case SCI_SURFACE:
2536     case SCI_AXES:
2537     case SCI_LEGEND:
2538     case SCI_SEGS:
2539     case SCI_FEC:
2540     case SCI_GRAYPLOT:
2541     case SCI_AGREG:
2542     case SCI_UIMENU:
2543     default:
2544         printSetGetErrorMessage("box_type");
2545         return 0;
2546         break;
2547     }
2548     return 0;
2549 }
2550
2551 int * sciGetInterpVector(sciPointObj * pobj)
2552 {
2553
2554     if(sciGetEntityType(pobj) != SCI_POLYLINE)
2555         return (int *) NULL;
2556
2557     return pPOLYLINE_FEATURE(pobj)->scvector;
2558 }
2559
2560 BOOL sciGetIsColorInterpolated(sciPointObj * pobj)
2561 {
2562     switch ( sciGetEntityType (pobj) )
2563     {
2564     case SCI_POLYLINE:
2565         return pPOLYLINE_FEATURE(pobj)->isinterpshaded;
2566     default:
2567         printSetGetErrorMessage("interp_vector");
2568         break;
2569     }
2570     return FALSE;
2571 }
2572
2573 BOOL sciGetAutoRotation ( sciPointObj * pObj )
2574 {
2575     switch (sciGetEntityType (pObj))
2576     {
2577     case SCI_LABEL:
2578         return pLABEL_FEATURE(pObj)->auto_rotation ;
2579         break;
2580     case SCI_POLYLINE:
2581     case SCI_RECTANGLE:
2582     case SCI_ARC:
2583     case SCI_TEXT:
2584     case SCI_FIGURE:
2585     case SCI_SUBWIN:
2586     case SCI_SURFACE:
2587     case SCI_AXES:
2588     case SCI_FEC:
2589     case SCI_SEGS:
2590     case SCI_LEGEND:
2591     case SCI_GRAYPLOT:
2592     case SCI_AGREG:
2593     case SCI_UIMENU:
2594     default:
2595         return FALSE;
2596         break;
2597     }
2598     return FALSE;
2599 }
2600
2601 BOOL sciGetAutoPosition ( sciPointObj * pObj )
2602 {
2603     switch (sciGetEntityType (pObj))
2604     {
2605     case SCI_LABEL:
2606         return pLABEL_FEATURE(pObj)->auto_position ;
2607         break;
2608     case SCI_POLYLINE:
2609     case SCI_RECTANGLE:
2610     case SCI_ARC:
2611     case SCI_TEXT:
2612     case SCI_FIGURE:
2613     case SCI_SUBWIN:
2614     case SCI_SURFACE:
2615     case SCI_AXES:
2616     case SCI_FEC:
2617     case SCI_SEGS:
2618     case SCI_LEGEND:
2619     case SCI_GRAYPLOT:
2620     case SCI_AGREG:
2621     case SCI_UIMENU:
2622     default:
2623         return FALSE;
2624         break;
2625     }
2626     return FALSE;
2627 }
2628
2629 /*-----------------------------------------------------------------------------------*/
2630 BOOL sciGetLegendDefined(char * pObjUID)
2631 {
2632     char* xLabelId = NULL;
2633     char* yLabelId = NULL;
2634     char* zLabelId = NULL;
2635
2636     if (pObjUID == NULL)
2637     {
2638         return FALSE;
2639     }
2640
2641     getGraphicObjectProperty(pObjUID, __GO_X_AXIS_LABEL__, jni_string, &xLabelId);
2642     getGraphicObjectProperty(pObjUID, __GO_Y_AXIS_LABEL__, jni_string, &yLabelId);
2643     getGraphicObjectProperty(pObjUID, __GO_Z_AXIS_LABEL__, jni_string, &zLabelId);
2644
2645     /* get the text size of labels */
2646     if (sciisTextEmpty(xLabelId) &&
2647         sciisTextEmpty(yLabelId) &&
2648         sciisTextEmpty(zLabelId))
2649     {
2650         return FALSE;
2651     }
2652     else
2653     {
2654         return TRUE;
2655     }
2656 }
2657 /*-----------------------------------------------------------------------------------*/
2658 BOOL sciGetAutoSize( sciPointObj * pObj )
2659 {
2660     switch (sciGetEntityType (pObj))
2661     {
2662     case SCI_TEXT:
2663         return pTEXT_FEATURE(pObj)->autoSize ;
2664         break;
2665     default:
2666         return FALSE;
2667         break;
2668     }
2669     return FALSE;
2670 }
2671 /*-----------------------------------------------------------------------------------*/
2672 sciTextAlignment sciGetAlignment( sciPointObj * pObj )
2673 {
2674     switch (sciGetEntityType (pObj))
2675     {
2676     case SCI_TEXT:
2677         return pTEXT_FEATURE(pObj)->stringsAlign ;
2678         break;
2679     default:
2680         printSetGetErrorMessage("text_alignment");
2681         return ALIGN_NONE ;
2682     }
2683     return ALIGN_NONE ;
2684 }
2685 /*-----------------------------------------------------------------------------------*/
2686 void sciGetUserSize( sciPointObj * pObj, double * width, double * height )
2687 {
2688     switch( sciGetEntityType( pObj ) )
2689     {
2690     case SCI_TEXT:
2691         *width  = pTEXT_FEATURE(pObj)->userSize[0] ;
2692         *height = pTEXT_FEATURE(pObj)->userSize[1] ;
2693         break ;
2694     default:
2695         printSetGetErrorMessage("text_box");
2696         break ;
2697     }
2698 }
2699 /*-----------------------------------------------------------------------------------*/
2700 /**
2701 * get how is displayed the text around its position.
2702 * If TRUE, the position is the middle of the displayed string.
2703 * If FALSE, it is the lower right corner.
2704 */
2705 BOOL sciGetCenterPos( sciPointObj * pObj )
2706 {
2707     switch( sciGetEntityType( pObj ) )
2708     {
2709     case SCI_TEXT:
2710         return pTEXT_FEATURE(pObj)->centeredPos ;
2711         break ;
2712     default:
2713         printSetGetErrorMessage("text_box_mode");
2714         return FALSE ;
2715     }
2716 }
2717 /*-----------------------------------------------------------------------------------*/
2718 /**
2719 * return wether the current object is displayed in 2d or 3d mode.
2720 */
2721 BOOL sciGetIs3d( sciPointObj * pObj )
2722 {
2723     switch( sciGetEntityType( pObj ) )
2724     {
2725     case SCI_SUBWIN:
2726         return pSUBWIN_FEATURE(pObj)->is3d ;
2727     case SCI_TEXT:
2728         return pTEXT_FEATURE( pObj )->is3d ;
2729     case SCI_LABEL:
2730         return sciGetIs3d( pLABEL_FEATURE( pObj )->text ) ;
2731     default:
2732         printSetGetErrorMessage("view");
2733         return FALSE ;
2734     }
2735     return FALSE ;
2736 }
2737 /*-----------------------------------------------------------------------------------*/
2738 /**
2739 * get the number of children of a graphic object
2740 * @return number of children of object pObj
2741 */
2742 int sciGetNbChildren( sciPointObj * pObj )
2743 {
2744     int nbChildren = 0 ;
2745     sciSons * curSon = sciGetSons( pObj ) ;
2746     while ( curSon != NULL && curSon->pointobj != NULL )
2747     {
2748         nbChildren++ ;
2749         curSon = curSon->pnext ;
2750     }
2751     return nbChildren ;
2752 }
2753 /*-----------------------------------------------------------------------------------*/
2754 /**
2755 * Return if an object directly accessible as a son of an other in Scilab.
2756 * For instance, Label objects are not accessible.
2757 * @return TRUE if the object is accessible, FALSE otherwise.
2758 */
2759 BOOL sciGetIsAccessibleChild( sciPointObj * pObj )
2760 {
2761     return sciGetEntityType( pObj ) != SCI_LABEL
2762         && GetHandleVisibilityOnUimenu( pObj ) ;
2763 }
2764 /*-----------------------------------------------------------------------------------*/
2765 BOOL GetHandleVisibilityOnUimenu( sciPointObj * pobj )
2766 {
2767     if (sciGetEntityType(pobj)!=SCI_UIMENU) { return TRUE ; }
2768
2769     return pUIMENU_FEATURE(pobj)->handle_visible;
2770 }
2771 /*-----------------------------------------------------------------------------------*/
2772 /**
2773 * return the number of object of a certain type which can be found among the descendants
2774 * of an object.
2775 * To get the number of surfaces of a subwindow, it is much faster to use the
2776 * sciGetSubwinNbSurf funtion.
2777 */
2778 int sciGetNbTypedObjects( sciPointObj * pObj, sciEntityType type )
2779 {
2780     int nbFound = 0 ;
2781     sciSons * curSon ;
2782
2783     curSon = sciGetSons( pObj ) ;
2784     while( curSon != NULL )
2785     {
2786         if ( sciGetEntityType( curSon->pointobj ) == type )
2787         {
2788             nbFound++ ;
2789         }
2790         nbFound += sciGetNbTypedObjects( curSon->pointobj, type ) ;
2791         curSon = curSon->pnext ;
2792     }
2793     return nbFound ;
2794 }
2795 /*-----------------------------------------------------------------------------------*/
2796 /**
2797 * return the hidden color of a surface or the inherated attribute of a subwindow.
2798 */
2799 int sciGetHiddenColor( sciPointObj * pObj )
2800 {
2801
2802     int colorIndex;
2803     switch( sciGetEntityType( pObj ) )
2804     {
2805     case SCI_SUBWIN:
2806         colorIndex = pSUBWIN_FEATURE(pObj)->hiddencolor;
2807         break;
2808     case SCI_SURFACE:
2809         colorIndex = pSURFACE_FEATURE(pObj)->hiddencolor;
2810         break;
2811     default:
2812         printSetGetErrorMessage("hidden_color");
2813         return -10 ;
2814     }
2815     return colorIndex ;
2816 }
2817 /*----------------------------------------------------------------------------------*/
2818 /**
2819 * return the color of the back trihedron of an subwin object.
2820 */
2821 int sciGetHiddenAxisColor( sciPointObj * pObj )
2822 {
2823
2824     int colorIndex;
2825     switch( sciGetEntityType( pObj ) )
2826     {
2827     case SCI_SUBWIN:
2828         colorIndex = pSUBWIN_FEATURE(pObj)->axes.hiddenAxisColor + 1 ;
2829         break;
2830     default:
2831         printSetGetErrorMessage("hidden_axis_color");
2832         return -10 ;
2833     }
2834     colorIndex = sciGetGoodIndex(pObj, colorIndex);
2835     return colorIndex ;
2836 }
2837 /*----------------------------------------------------------------------------------*/
2838 /**
2839 * return if the drawlater mode is on for the parent figure.
2840 */
2841 BOOL sciGetIsAutoDrawable( sciPointObj * pobj )
2842 {
2843     return (sciGetImmediateDrawingMode(pobj) && !sciGetPixmapMode(pobj));
2844 }
2845 /*----------------------------------------------------------------------------------*/
2846 BOOL sciGetImmediateDrawingMode(sciPointObj * pobj)
2847 {
2848     return pFIGURE_FEATURE(sciGetParentFigure(pobj))->auto_redraw ;
2849 }
2850 /*----------------------------------------------------------------------------------*/
2851 /**
2852 * To retrieve the type of grid for each dimension
2853 */
2854 void sciGetGridStyle( sciPointObj * pObj, int * xStyle, int * yStyle, int * zStyle )
2855 {
2856     switch ( sciGetEntityType (pObj) )
2857     {
2858     case SCI_SUBWIN:
2859         if (xStyle != NULL) {*xStyle = pSUBWIN_FEATURE(pObj)->grid[0];}
2860         if (yStyle != NULL) {*yStyle = pSUBWIN_FEATURE(pObj)->grid[1];}
2861         if (zStyle != NULL) {*zStyle = pSUBWIN_FEATURE(pObj)->grid[2];}
2862         break ;
2863     default:
2864         printSetGetErrorMessage("grid");
2865         break;
2866     }
2867 }
2868 /*----------------------------------------------------------------------------------*/
2869 /**
2870 * To retrieve the viewport property
2871 * viewport property is only enable when the auto_resize property of the figure is
2872 * disable.
2873 */
2874 void sciGetViewport( sciPointObj * pObj, int viewport[4] )
2875 {
2876     switch ( sciGetEntityType(pObj) )
2877     {
2878     case SCI_FIGURE:
2879         if (isFigureModel(pObj->UID))
2880         {
2881             viewport[0] = pFIGURE_FEATURE(pObj)->pModelData->viewport[0];
2882             viewport[1] = pFIGURE_FEATURE(pObj)->pModelData->viewport[1];
2883             viewport[2] = pFIGURE_FEATURE(pObj)->pModelData->viewport[2];
2884             viewport[3] = pFIGURE_FEATURE(pObj)->pModelData->viewport[3];
2885         }
2886         else
2887         {
2888             sciGetJavaViewport(pObj, viewport);
2889         }
2890         break;
2891     default:
2892         printSetGetErrorMessage("viewport");
2893         break;
2894     }
2895 }
2896 /*----------------------------------------------------------------------------------*/
2897 void sciGetInfoMessage( sciPointObj * pObj, char * infoMessage )
2898 {
2899     switch ( sciGetEntityType(pObj) )
2900     {
2901     case SCI_FIGURE:
2902         if (isFigureModel(pObj->UID))
2903         {
2904             strcpy(infoMessage, pFIGURE_FEATURE(pObj)->pModelData->infoMessage);
2905         }
2906         else
2907         {
2908             sciGetJavaInfoMessage(pObj, infoMessage);
2909         }
2910         break;
2911     default:
2912         printSetGetErrorMessage("info_message");
2913         break;
2914     }
2915 }
2916 /*----------------------------------------------------------------------------------*/
2917 int sciGetInfoMessageLength( sciPointObj * pObj )
2918 {
2919     switch ( sciGetEntityType(pObj) )
2920     {
2921     case SCI_FIGURE:
2922         if (isFigureModel(pObj->UID))
2923         {
2924             return (int) strlen( pFIGURE_FEATURE(pObj)->pModelData->infoMessage ) ;
2925         }
2926         else
2927         {
2928             return sciGetJavaInfoMessageLength(pObj);
2929         }
2930     default:
2931         printSetGetErrorMessage("info_message");
2932         return -1 ;
2933     }
2934     return -1 ;
2935
2936 }
2937 /*----------------------------------------------------------------------------------*/
2938 void sciGetScreenPosition( sciPointObj * pObj, int * posX, int * posY )
2939 {
2940     switch ( sciGetEntityType(pObj) )
2941     {
2942     case SCI_FIGURE:
2943         if ( pObj == getFigureModel() )
2944         {
2945             *posX = pFIGURE_FEATURE(pObj)->pModelData->windowPosition[0] ;
2946             *posY = pFIGURE_FEATURE(pObj)->pModelData->windowPosition[1] ;
2947         }
2948         else
2949         {
2950             int pos[2];
2951             sciGetJavaWindowPosition(pObj, pos) ;
2952             *posX = pos[0] ;
2953             *posY = pos[1] ;
2954         }
2955         break ;
2956     default:
2957         printSetGetErrorMessage("figure_position");
2958         *posX = -1 ;
2959         *posY = -1 ;
2960     }
2961 }
2962 /*----------------------------------------------------------------------------------*/
2963 BOOL sciGetIsEventHandlerEnable( sciPointObj * pObj )
2964 {
2965     switch ( sciGetEntityType(pObj) )
2966     {
2967     case SCI_FIGURE:
2968         {
2969             return pFIGURE_FEATURE( pObj )->isEventHandlerEnable ;
2970         }
2971         break ;
2972     default:
2973         printSetGetErrorMessage("event_handler");
2974         return FALSE ;
2975     }
2976     return FALSE ;
2977 }
2978 /*----------------------------------------------------------------------------------*/
2979 char * sciGetEventHandler( sciPointObj * pObj )
2980 {
2981     switch ( sciGetEntityType(pObj) )
2982     {
2983     case SCI_FIGURE:
2984         {
2985             return pFIGURE_FEATURE(pObj)->eventHandler ;
2986         }
2987         break ;
2988     default:
2989         printSetGetErrorMessage("event_handler");
2990         return NULL ;
2991     }
2992     return NULL ;
2993 }
2994 /*----------------------------------------------------------------------------------*/
2995 double * sciGetAxesBounds( sciPointObj * pObj )
2996 {
2997     switch( sciGetEntityType(pObj) )
2998     {
2999     case SCI_SUBWIN:
3000         return pSUBWIN_FEATURE(pObj)->WRect;
3001     default:
3002         printSetGetErrorMessage("axes_bounds");
3003         return NULL ;
3004     }
3005 }
3006 /*----------------------------------------------------------------------------------*/
3007 double * sciGetMargins( sciPointObj * pObj )
3008 {
3009     switch( sciGetEntityType(pObj) )
3010     {
3011     case SCI_SUBWIN:
3012         return pSUBWIN_FEATURE(pObj)->ARect;
3013     default:
3014         printSetGetErrorMessage("margins");
3015         return NULL ;
3016     }
3017 }
3018 /*----------------------------------------------------------------------------------*/
3019 /**
3020 * To get the computed data bounds of a subwin.
3021 * * @param bounds [Xmin,Xmax,Ymin,Ymax,Zmin,Zmax] vector.
3022 */
3023 void sciGetRealDataBounds( sciPointObj * pObj, double bounds[6] )
3024 {
3025     int i;
3026     switch( sciGetEntityType(pObj) )
3027     {
3028     case SCI_SUBWIN:
3029         for ( i = 0 ; i < 6 ; i++ )
3030         {
3031             bounds[i] = pSUBWIN_FEATURE(pObj)->FRect[i] ;
3032         }
3033         return ;
3034     default:
3035         printSetGetErrorMessage("data_bounds");
3036         for ( i = 0 ; i < 6 ; i++ )
3037         {
3038             bounds[i] = 0.0 ;
3039         }
3040     }
3041     return ;
3042 }
3043 /*----------------------------------------------------------------------------------*/
3044 /**
3045 * Get the bounds we need to use for a subwin (between user defined one and zoomed ones).
3046 */
3047 void sciGetDisplayedDataBounds(sciPointObj * pObj, double bounds[6])
3048 {
3049     if(sciGetZooming(pObj))
3050     {
3051         sciGetZoomBox(pObj, bounds);
3052     }
3053     else
3054     {
3055         sciGetDataBounds(pObj, bounds);
3056     }
3057 }
3058 /*----------------------------------------------------------------------------------*/
3059 /**
3060 * Get data-bounds defined by the user and not modified for pretty print by scilab.
3061 * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
3062 */
3063 void sciGetDataBounds( sciPointObj * pObj, double bounds[6] )
3064 {
3065     int i;
3066     switch( sciGetEntityType(pObj) )
3067     {
3068     case SCI_SUBWIN:
3069         for ( i = 0 ; i < 6 ; i++ )
3070         {
3071             bounds[i] = pSUBWIN_FEATURE(pObj)->SRect[i] ;
3072         }
3073         return ;
3074     case SCI_SURFACE:
3075         for ( i = 0 ; i < 6 ; i++ )
3076         {
3077             bounds[i] = pSURFACE_FEATURE(pObj)->ebox[i] ;
3078         }
3079         return ;
3080     default:
3081         printSetGetErrorMessage("data_bounds");
3082         for ( i = 0 ; i < 6 ; i++ )
3083         {
3084             bounds[i] = 0.0 ;
3085         }
3086     }
3087     return ;
3088 }
3089 /*----------------------------------------------------------------------------------*/
3090 /**
3091 * Get the viewing angles of a subwindow in degrees.
3092 */
3093 void sciGetViewingAngles( sciPointObj * pObj, double * alpha, double * theta)
3094 {
3095     switch( sciGetEntityType(pObj) )
3096     {
3097     case SCI_SUBWIN:
3098         *alpha = pSUBWIN_FEATURE(pObj)->alpha;
3099         *theta = pSUBWIN_FEATURE(pObj)->theta;
3100         break;
3101     default:
3102         printSetGetErrorMessage("rotation_angles");
3103         *alpha = 0.0;
3104         *theta = 0.0;
3105         break;
3106     }
3107 }
3108 /*----------------------------------------------------------------------------------*/
3109 /**
3110 * Copy the logflags of a subwin to an array of size 3.
3111 */
3112 void sciGetLogFlags(char * pObjUID, char flags[3])
3113 {
3114     char* logflagPropertyNames[3] = {__GO_X_AXIS_LOG_FLAG__, __GO_Y_AXIS_LOG_FLAG__, __GO_Z_AXIS_LOG_FLAG__};
3115     int i;
3116     int iLogFlag = 0;
3117     int* piLogFlag = &iLogFlag;
3118
3119     for (i = 0; i < 3; i++)
3120     {
3121         getGraphicObjectProperty(pObjUID, logflagPropertyNames[i], jni_bool, &piLogFlag);
3122
3123         if (piLogFlag == NULL)
3124         {
3125             printSetGetErrorMessage("log_flags");
3126             return;
3127         }
3128
3129         if (iLogFlag)
3130         {
3131             flags[i] = 'l';
3132         }
3133         else
3134         {
3135             flags[i] = 'n';
3136         }
3137     }
3138 }
3139 /*----------------------------------------------------------------------------------*/
3140 /**
3141 * To know if the pixmap mode a figure is on or off.
3142 */
3143 BOOL sciGetPixmapMode(sciPointObj * pObj)
3144 {
3145     switch(sciGetEntityType(pObj))
3146     {
3147     case SCI_FIGURE:
3148         return pFIGURE_FEATURE(pObj)->pixmapMode;
3149         break;
3150     default:
3151         printSetGetErrorMessage("pixmap");
3152         break;
3153     }
3154     return FALSE;
3155 }
3156 /*----------------------------------------------------------------------------------*/
3157 /**
3158 * @return number of vertices of a pointObj
3159 */
3160 int sciGetNbPoints(sciPointObj * pObj)
3161 {
3162     switch(sciGetEntityType(pObj))
3163     {
3164     case SCI_POLYLINE:
3165         return pPOLYLINE_FEATURE(pObj)->n1;
3166     default:
3167         printSetGetErrorMessage("points");
3168         break;
3169     }
3170     return -1;
3171 }
3172 /*----------------------------------------------------------------------------------*/
3173 int sciGetPolylineStyle(sciPointObj * pObj)
3174 {
3175     switch(sciGetEntityType(pObj))
3176     {
3177     case SCI_POLYLINE:
3178         return pPOLYLINE_FEATURE(pObj)->plot;
3179     default:
3180         printSetGetErrorMessage("polyline_style");
3181         break;
3182     }
3183     return -1;
3184 }
3185 /*----------------------------------------------------------------------------------*/
3186 BOOL sciGetIsClosed(sciPointObj * pObj)
3187 {
3188     switch(sciGetEntityType(pObj))
3189     {
3190     case SCI_POLYLINE:
3191         return pPOLYLINE_FEATURE(pObj)->closed;
3192     default:
3193         printSetGetErrorMessage("closed");
3194         break;
3195     }
3196     return FALSE;
3197 }
3198 /*----------------------------------------------------------------------------------*/
3199 double sciGetArrowSize(sciPointObj * pObj)
3200 {
3201     switch(sciGetEntityType(pObj))
3202     {
3203     case SCI_POLYLINE:
3204         return pPOLYLINE_FEATURE(pObj)->arsize_factor;
3205     case SCI_SEGS:
3206         return pSEGS_FEATURE(pObj)->arrowsize;
3207     default:
3208         printSetGetErrorMessage("arrow_size");
3209         break;
3210     }
3211     return -1;
3212 }
3213 /*----------------------------------------------------------------------------------*/
3214 void sciGetTextPos(sciPointObj * pObj, double position[3])
3215 {
3216     switch(sciGetEntityType(pObj))
3217     {
3218     case SCI_TEXT:
3219         position[0] = pTEXT_FEATURE(pObj)->x;
3220         position[1] = pTEXT_FEATURE(pObj)->y;
3221         position[2] = pTEXT_FEATURE(pObj)->z;
3222         break;
3223     case SCI_LABEL:
3224         sciGetTextPos(pLABEL_FEATURE(pObj)->text, position);
3225         break;
3226     default:
3227         printSetGetErrorMessage("data");
3228         position[0] = 0.0;
3229         position[1] = 0.0;
3230         position[2] = 0.0;
3231         break;
3232     }
3233 }
3234 /*----------------------------------------------------------------------------------*/
3235 /**
3236 * Convert user coordinates to pixel ones (relative to the viewing canvas).
3237 * @param pObj subwindow handle
3238 * @param userCoord user coordinates
3239 * @param pixCoord result in pixels.
3240 */
3241 void sciGetPixelCoordinate(sciPointObj * pObj, const double userCoord[3], int pixCoord[2])
3242 {
3243     switch(sciGetEntityType(pObj))
3244     {
3245     case SCI_SUBWIN:
3246         sciGetJavaPixelCoordinates(pObj, userCoord, pixCoord);
3247         break;
3248     default:
3249         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3250         pixCoord[0] = -1;
3251         pixCoord[1] = -1;
3252         break;
3253     }
3254 }
3255 /*----------------------------------------------------------------------------------*/
3256 /**
3257 * Convert user coordinates to user cooordinates (2D).
3258 * @param pObj subwindow handle
3259 * @param userCoord3D user coordinates
3260 * @param userCoords2D result in user coordinates in the default 2D plane.
3261 */
3262 void sciGet2dViewCoordinate(sciPointObj * pObj, const double userCoords3D[3], double userCoords2D[2])
3263 {
3264     switch(sciGetEntityType(pObj))
3265     {
3266     case SCI_SUBWIN:
3267         sciGetJava2dViewCoordinates(pObj, userCoords3D, userCoords2D);
3268         break;
3269     default:
3270         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3271         userCoords2D[0] = 0.0;
3272         userCoords2D[1] = 0.0;
3273         break;
3274     }
3275 }
3276 /*----------------------------------------------------------------------------------*/
3277 /**
3278 * Convert pixel coordinates to 2D view coordinate
3279 * @param pObj subwindow handle
3280 * @param userCoord pixel coordinates
3281 * @param userCoords2D user coordinates in default 2D plane
3282 */
3283 void sciGet2dViewCoordFromPixel(sciPointObj * pObj, const int pixelCoords[2], double userCoords2D[2])
3284 {
3285     switch(sciGetEntityType(pObj))
3286     {
3287     case SCI_SUBWIN:
3288         sciGetJava2dViewCoordFromPixel(pObj, pixelCoords, userCoords2D);
3289         break;
3290     default:
3291         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3292         userCoords2D[0] = 0.0;
3293         userCoords2D[1] = 0.0;
3294         break;
3295     }
3296 }
3297 /*----------------------------------------------------------------------------------*/
3298 /**
3299 * Convert 2d view coordinates to pixel coordinates
3300 * @param pObj subwindow handle
3301 * @param userCoords2D coordinates in th default 2D plane
3302 * @param pixelsCoords pixel coordinates
3303 */
3304 void sciGet2dViewPixelCoordinates(sciPointObj * pObj, const double userCoords2D[2], int pixelCoords[2])
3305 {
3306     switch(sciGetEntityType(pObj))
3307     {
3308     case SCI_SUBWIN:
3309         {
3310             /* create a 3d user coord */
3311             double userCoord3D[3] = {userCoords2D[0], userCoords2D[1], 0.0};
3312             sciGetJava2dViewPixelCoordinates(pObj, userCoord3D, pixelCoords);
3313         }
3314         break;
3315     default:
3316         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3317         pixelCoords[0] = -1;
3318         pixelCoords[1] = -1;
3319         break;
3320     }
3321 }
3322 /*----------------------------------------------------------------------------------*/
3323 /**
3324 * @return TRUE if pObj is a subwin with isoview mode on.
3325 */
3326 BOOL sciGetIsIsoView(sciPointObj * pObj)
3327 {
3328     switch(sciGetEntityType(pObj))
3329     {
3330     case SCI_SUBWIN:
3331         return pSUBWIN_FEATURE(pObj)->isoview;
3332     default:
3333         return FALSE;
3334         break;
3335     }
3336 }
3337 /*----------------------------------------------------------------------------------*/
3338 /**
3339 * @return TRUE if pObj is a subwindow with cube scaling mode on.
3340 */
3341 BOOL sciGetIsCubeScaled(sciPointObj * pObj)
3342 {
3343     switch(sciGetEntityType(pObj))
3344     {
3345     case SCI_SUBWIN:
3346         return pSUBWIN_FEATURE(pObj)->cube_scaling;
3347     default:
3348         return FALSE;
3349         break;
3350     }
3351 }
3352 /*----------------------------------------------------------------------------------*/
3353 /**
3354 * Get axes reverse property for each axis of a subwin object
3355 */
3356 void sciGetAxesReverse(sciPointObj * pObj, BOOL axesReverse[3])
3357 {
3358     switch(sciGetEntityType(pObj))
3359     {
3360     case SCI_SUBWIN:
3361         axesReverse[0] = pSUBWIN_FEATURE(pObj)->axes.reverse[0];
3362         axesReverse[1] = pSUBWIN_FEATURE(pObj)->axes.reverse[1];
3363         axesReverse[2] = pSUBWIN_FEATURE(pObj)->axes.reverse[2];
3364         break;
3365     default:
3366         printSetGetErrorMessage("axes_reverse");
3367         break;
3368     }
3369 }
3370 /*----------------------------------------------------------------------------------*/
3371 /**
3372 * @return TRUE if subwindow pObj tight_limit mode is on.
3373 */
3374 BOOL sciGetTightLimitsOn(sciPointObj * pObj)
3375 {
3376     switch(sciGetEntityType(pObj))
3377     {
3378     case SCI_SUBWIN:
3379         return pSUBWIN_FEATURE(pObj)->tight_limits;
3380     default:
3381         return FALSE;
3382         break;
3383     }
3384 }
3385 /*----------------------------------------------------------------------------------*/
3386 /**
3387 * Get auto_ticks property for each axis
3388 */
3389 void sciGetAutoTicks(sciPointObj * pObj, BOOL autoTicks[3])
3390 {
3391     switch(sciGetEntityType(pObj))
3392     {
3393     case SCI_SUBWIN:
3394         autoTicks[0] = pSUBWIN_FEATURE(pObj)->axes.auto_ticks[0];
3395         autoTicks[1] = pSUBWIN_FEATURE(pObj)->axes.auto_ticks[1];
3396         autoTicks[2] = pSUBWIN_FEATURE(pObj)->axes.auto_ticks[2];
3397         break;
3398     default:
3399         autoTicks[0] = FALSE;
3400         autoTicks[1] = FALSE;
3401         autoTicks[2] = FALSE;
3402         printSetGetErrorMessage("auto_ticks");
3403         break;
3404     }
3405 }
3406 /*----------------------------------------------------------------------------------*/
3407 /**
3408 * Get auto_ticks property for each axis
3409 */
3410 BOOL sciGetAutoSubticks(sciPointObj * pObj)
3411 {
3412     switch(sciGetEntityType(pObj))
3413     {
3414     case SCI_SUBWIN:
3415         return !(pSUBWIN_FEATURE(pObj)->flagNax);
3416         break;
3417     default:
3418         return FALSE;
3419         printSetGetErrorMessage("auto_subticks");
3420         break;
3421     }
3422 }
3423 /*----------------------------------------------------------------------------------*/
3424 /**
3425 * Get nbsubtics for each axis
3426 */
3427 void sciGetNbSubTics(sciPointObj * pObj, int nbsubtics[3])
3428 {
3429     switch(sciGetEntityType(pObj))
3430     {
3431     case SCI_SUBWIN:
3432         nbsubtics[0] = pSUBWIN_FEATURE(pObj)->axes.nbsubtics[0];
3433         nbsubtics[1] = pSUBWIN_FEATURE(pObj)->axes.nbsubtics[1];
3434         nbsubtics[2] = pSUBWIN_FEATURE(pObj)->axes.nbsubtics[2];
3435         break;
3436     default:
3437         nbsubtics[0] = 0;
3438         nbsubtics[1] = 0;
3439         nbsubtics[2] = 0;
3440         printSetGetErrorMessage("nbsubtics");
3441         break;
3442     }
3443 }
3444 /*----------------------------------------------------------------------------------*/
3445 /**
3446 * Get the axes visible property for each axis.
3447 */
3448 void sciGetAxesVisible(sciPointObj * pObj, BOOL axesVisible[3])
3449 {
3450     switch(sciGetEntityType(pObj))
3451     {
3452     case SCI_SUBWIN:
3453         axesVisible[0] = pSUBWIN_FEATURE(pObj)->axes.axes_visible[0];
3454         axesVisible[1] = pSUBWIN_FEATURE(pObj)->axes.axes_visible[1];
3455         axesVisible[2] = pSUBWIN_FEATURE(pObj)->axes.axes_visible[2];
3456         break;
3457     default:
3458         axesVisible[0] = FALSE;
3459         axesVisible[1] = FALSE;
3460         axesVisible[2] = FALSE;
3461         printSetGetErrorMessage("axes_visible");
3462         break;
3463     }
3464 }
3465 /*----------------------------------------------------------------------------------*/
3466 /**
3467 * Get the current zoom box of a subwin object
3468 * @param[out] zoomBox output parameter with thte zoom box
3469 */
3470 void sciGetZoomBox(sciPointObj * pObj, double zoomBox[6])
3471 {
3472     switch(sciGetEntityType(pObj))
3473     {
3474     case SCI_SUBWIN:
3475         zoomBox[0] = pSUBWIN_FEATURE(pObj)->ZRect[0] ;
3476         zoomBox[1] = pSUBWIN_FEATURE(pObj)->ZRect[1] ;
3477         zoomBox[2] = pSUBWIN_FEATURE(pObj)->ZRect[2] ;
3478         zoomBox[3] = pSUBWIN_FEATURE(pObj)->ZRect[3] ;
3479         zoomBox[4] = pSUBWIN_FEATURE(pObj)->ZRect[4] ;
3480         zoomBox[5] = pSUBWIN_FEATURE(pObj)->ZRect[5] ;
3481         break;
3482     default:
3483         printSetGetErrorMessage("zoom_box");
3484         break;
3485     }
3486 }
3487 /*----------------------------------------------------------------------------------*/
3488 /**
3489 * Get the 4 corners of the bounding box of a text object in 3D
3490 */
3491 void sciGetTextBoundingBox(sciPointObj * pObj, double corner1[3], double corner2[3],
3492                            double corner3[3], double corner4[3])
3493 {
3494     switch (sciGetEntityType(pObj))
3495     {
3496     case SCI_TEXT:
3497         {
3498             int i;
3499             for (i = 0; i < 3; i++)
3500             {
3501                 // should be up to date
3502                 corner1[i] = pTEXT_FEATURE(pObj)->corners[0][i];
3503                 corner2[i] = pTEXT_FEATURE(pObj)->corners[1][i];
3504                 corner3[i] = pTEXT_FEATURE(pObj)->corners[2][i];
3505                 corner4[i] = pTEXT_FEATURE(pObj)->corners[3][i];
3506             }
3507         }
3508         break;
3509     case SCI_LABEL:
3510         sciGetTextBoundingBox(pLABEL_FEATURE(pObj)->text, corner1, corner2, corner3, corner4);
3511         break;
3512
3513     default:
3514         printSetGetErrorMessage("bounding box");
3515         break;
3516     }
3517 }
3518 /*----------------------------------------------------------------------------------*/
3519 /**
3520 * Get the 4 corners of the bounding box of a text object in pixels
3521 */
3522 void sciGetPixelBoundingBox(sciPointObj * pObj, int corner1[2], int corner2[2],
3523                             int corner3[2], int corner4[2])
3524 {
3525     sciGetJavaPixelBoundingBox(pObj, corner1, corner2, corner3, corner4);
3526 }
3527 /*----------------------------------------------------------------------------------*/
3528 /**
3529 * Get the 4 corners of the boundng box of a text object in 2D view user coordinates.
3530 */
3531 void sciGet2dViewBoundingBox(sciPointObj * pObj, double corner1[2], double corner2[2],
3532                              double corner3[2], double corner4[2])
3533 {
3534     sciPointObj * parentSubwin = sciGetParentSubwin(pObj);
3535     double corners3d[4][3];
3536
3537     /* get bounding box */
3538     sciGetTextBoundingBox(pObj, corners3d[0], corners3d[1], corners3d[2], corners3d[3]);
3539
3540     /* convert it to 2d view coordinates */
3541     sciGetJava2dViewCoordinates(parentSubwin, corners3d[0], corner1);
3542     sciGetJava2dViewCoordinates(parentSubwin, corners3d[1], corner2);
3543     sciGetJava2dViewCoordinates(parentSubwin, corners3d[2], corner3);
3544     sciGetJava2dViewCoordinates(parentSubwin, corners3d[3], corner4);
3545
3546 }
3547 /*----------------------------------------------------------------------------------*/
3548 /**
3549 * Get the viewing area of a subwindown acoordinf to its axes scale and margins
3550 * result is in pixels
3551 */
3552 void sciGetViewingArea(sciPointObj * pObj, int * xPos, int * yPos, int * width, int * height)
3553 {
3554     switch (sciGetEntityType(pObj))
3555     {
3556     case SCI_SUBWIN:
3557         sciGetJavaViewingArea(pObj, xPos, yPos, width, height);
3558         break;
3559     default:
3560         *xPos = -1;
3561         *yPos = -1;
3562         *width = -1;
3563         *height = -1;
3564         Scierror(999, _("Only axes handles have a viewing area."));
3565         break;
3566     }
3567 }
3568 /*----------------------------------------------------------------------------------*/
3569 /**
3570 * Get the axis aligned bounding box a graphic object
3571 * @param bounds [xmin, xmax, ymin, ymax, zmin, zmax] bounds.
3572 */
3573 void sciGetAABoundingBox(sciPointObj * pObj, double bounds[6])
3574 {
3575     switch (sciGetEntityType(pObj))
3576     {
3577     case SCI_SUBWIN:
3578         sciGetDataBounds(pObj, bounds);
3579         break;
3580     case SCI_SEGS:
3581         sciGetJavaSegsBoundingBox(pObj, bounds);
3582         break;
3583     case SCI_TEXT:
3584         {
3585             double corners[4][3];
3586             sciGetTextBoundingBox(pObj, corners[0], corners[1], corners[2], corners[3]);
3587             bounds[0] = Min(corners[0][0],Min(corners[1][0],Min(corners[2][0],corners[3][0])));
3588             bounds[1] = Max(corners[0][0],Max(corners[1][0],Max(corners[2][0],corners[3][0])));
3589             bounds[2] = Min(corners[0][1],Min(corners[1][1],Min(corners[2][1],corners[3][1])));
3590             bounds[3] = Max(corners[0][1],Max(corners[1][1],Max(corners[2][1],corners[3][1])));
3591             bounds[4] = Min(corners[0][2],Min(corners[1][2],Min(corners[2][2],corners[3][2])));
3592             bounds[5] = Max(corners[0][2],Max(corners[1][2],Max(corners[2][2],corners[3][2])));
3593         }
3594         break;
3595     case SCI_LABEL:
3596         sciGetAABoundingBox(pLABEL_FEATURE(pObj)->text, bounds);
3597         break;
3598     default:
3599         Scierror(999, _("Unable to compute data bounds for this kind of object."));
3600         break;
3601     }
3602 }
3603 /*----------------------------------------------------------------------------------*/
3604 /**
3605 * Get the x_position value
3606 * @param bounds [xmin, xmax, ymin, ymax, zmin, zmax] bounds.
3607 */
3608 char sciGetxLocation(sciPointObj * pObj)
3609 {
3610     switch (sciGetEntityType(pObj))
3611     {
3612     case SCI_SUBWIN:
3613         return pSUBWIN_FEATURE(pObj)->axes.xdir;
3614         break;
3615     default:
3616         Scierror(999, _("Unable to compute x_location for this kind of object."));
3617         break;
3618     }
3619     return NULL;
3620 }
3621 /*----------------------------------------------------------------------------------*/
3622 char sciGetyLocation(sciPointObj * pObj)
3623 {
3624     switch (sciGetEntityType(pObj))
3625     {
3626     case SCI_SUBWIN:
3627         return pSUBWIN_FEATURE(pObj)->axes.ydir;
3628         break;
3629     default:
3630         Scierror(999, _("Unable to compute y_location for this kind of object."));
3631         break;
3632     }
3633     return NULL;
3634 }
3635 /*----------------------------------------------------------------------------------*/
3636 /**
3637 * Check wether an object is using nurbs for display or not
3638 */
3639 BOOL sciGetUseNurbs(sciPointObj * pObj)
3640 {
3641     switch (sciGetEntityType(pObj))
3642     {
3643     case SCI_SUBWIN:
3644         return pSUBWIN_FEATURE(pObj)->useNurbsForArcs;
3645     case SCI_ARC:
3646         return pARC_FEATURE(pObj)->useNurbs;
3647     default:
3648         printSetGetErrorMessage("drawing_method");
3649         return FALSE;
3650     }
3651 }
3652 /*----------------------------------------------------------------------------------*/
3653 /**
3654 * Check wether an object is using fractional metrics for text display
3655 */
3656 BOOL sciGetIsUsingFractionalMetrics(sciPointObj * pObj)
3657 {
3658     sciFont * fontContext = sciGetFontContext(pObj);
3659     if (fontContext != NULL) {
3660         return fontContext->useFractionalMetrics;
3661     }
3662     printSetGetErrorMessage("fractional_font");
3663     return FALSE;
3664 }
3665 /*----------------------------------------------------------------------------------*/
3666 /**
3667 * Get number of subticks on the x,y, and z axes.
3668 * This property is determined by the renderer module.
3669 */
3670 void sciGetNbSubticks(sciPointObj * pSubwin, double nbsubtics[3])
3671 {
3672     sciGetJavaNbSubticks(pSubwin, nbsubtics);
3673 }
3674 /*----------------------------------------------------------------------------------*/
3675 /**
3676 * Get number of ticks along X axis of a subwindow.
3677 */
3678 int sciGetNbXTicks(sciPointObj * pSubwin)
3679 {
3680     return sciGetJavaNbXTicks(pSubwin);
3681 }
3682 /*----------------------------------------------------------------------------------*/
3683 /**
3684 * Get the labels and positions of ticks along X axis.
3685 * String composing ticksLabels are allocated with MALLOC.
3686 */
3687 void sciGetXTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
3688 {
3689     sciGetJavaXTicksPos(pSubwin, ticksPos, ticksLabels);
3690 }
3691 /*----------------------------------------------------------------------------------*/
3692 /**
3693 * Get number of ticks along Y axis of a subwindow.
3694 */
3695 int sciGetNbYTicks(sciPointObj * pSubwin)
3696 {
3697     return sciGetJavaNbYTicks(pSubwin);
3698 }
3699 /*----------------------------------------------------------------------------------*/
3700 /**
3701 * Get the labels and positions of ticks along Y axis.
3702 * String composing ticksLabels are allocated with C++ new.
3703 */
3704 void sciGetYTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
3705 {
3706     sciGetJavaYTicksPos(pSubwin, ticksPos, ticksLabels);
3707 }
3708 /*----------------------------------------------------------------------------------*/
3709 /**
3710 * Get number of ticks along Z axis of a subwindow.
3711 */
3712 int sciGetNbZTicks(sciPointObj * pSubwin)
3713 {
3714     return sciGetJavaNbZTicks(pSubwin);
3715 }
3716 /*----------------------------------------------------------------------------------*/
3717 /**
3718 * Get the labels and positions of ticks along Z axis.
3719 * String composing ticksLabels are allocated with C++ new.
3720 */
3721 void sciGetZTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
3722 {
3723     sciGetJavaZTicksPos(pSubwin, ticksPos, ticksLabels);
3724 }
3725 /*----------------------------------------------------------------------------------*/
3726 /**
3727 * Get the labels and positions of ticks along Z axis.
3728 * String composing ticksLabels are allocated with C++ new.
3729 */
3730 BOOL sciGetIsAbleToCreateWindow(void)
3731 {
3732     return sciGetJavaIsAbleToCreateWindow();
3733 }
3734 /*----------------------------------------------------------------------------------*/
3735 /**
3736 * @return index of the subwin between all the subwins lying below its parent figure
3737 */
3738 int sciGetSubwinIndex(sciPointObj * pSubwin)
3739 {
3740     sciPointObj * parentFigure = sciGetParentFigure(pSubwin);
3741     int subwinIndex = 0;
3742     sciSons * pSons = sciGetSons(parentFigure);
3743
3744     while (pSons->pointobj != pSubwin)
3745     {
3746         if (sciGetEntityType(pSons->pointobj) == SCI_SUBWIN)
3747         {
3748             // subwin found
3749             subwinIndex++;
3750         }
3751         pSons = pSons->pnext;
3752     }
3753     return subwinIndex;
3754 }
3755 /*----------------------------------------------------------------------------------*/
3756 /**
3757 * @return TRUE if the object is automatically redraw and does not
3758 *         need to be explicitely drawn (using sciDrawObj).
3759 */
3760 BOOL sciIsAutomaticallyRedrawn(sciPointObj * pObj)
3761 {
3762     sciEntityType entityType = sciGetEntityType(pObj);
3763     return (entityType == SCI_UICONTROL)
3764         || (entityType == SCI_UIMENU)
3765         || (entityType == SCI_UICONTEXTMENU)
3766         || (entityType == SCI_WAITBAR)
3767         || (entityType == SCI_PROGRESSIONBAR);
3768 }
3769 /*----------------------------------------------------------------------------------*/
3770 /**
3771 * Get the subset of colormap bounds used by a particular object (colminmax).
3772 */
3773 void sciGetColorRange(sciPointObj * pObj, int subset[2])
3774 {
3775     switch (sciGetEntityType(pObj))
3776     {
3777     case SCI_FEC:
3778         subset[0] = pFEC_FEATURE(pObj)->colminmax[0];
3779         subset[1] = pFEC_FEATURE(pObj)->colminmax[1];
3780         break;
3781     default:
3782         printSetGetErrorMessage("color_range");
3783         subset[0] = 0;
3784         subset[1] = 0;
3785         break;
3786     }
3787 }
3788 /*----------------------------------------------------------------------------------*/
3789 /**
3790 * Get the color to use for an objects when it uses index outside of the colormap (colout).
3791 */
3792 void sciGetOutsideColor(sciPointObj * pObj, int colors[2])
3793 {
3794     switch (sciGetEntityType(pObj))
3795     {
3796     case SCI_FEC:
3797         colors[0] = pFEC_FEATURE(pObj)->colout[0];
3798         colors[1] = pFEC_FEATURE(pObj)->colout[1];
3799         break;
3800     default:
3801         printSetGetErrorMessage("outside_color");
3802         colors[0] = 0;
3803         colors[1] = 0;
3804         break;
3805     }
3806 }
3807 /*----------------------------------------------------------------------------------*/
3808 /**
3809 * Get the Z range used by a fec object (zminmax).
3810 */
3811 void sciGetZBounds(sciPointObj * pObj, double bounds[2])
3812 {
3813     switch (sciGetEntityType(pObj))
3814     {
3815     case SCI_FEC:
3816         bounds[0] = pFEC_FEATURE(pObj)->zminmax[0];
3817         bounds[1] = pFEC_FEATURE(pObj)->zminmax[1];
3818         break;
3819     default:
3820         printSetGetErrorMessage("z_bounds");
3821         bounds[0] = 0;
3822         bounds[1] = 0;
3823         break;
3824     }
3825 }
3826 /*----------------------------------------------------------------------------------*/
3827 /**
3828 * Get whether the grid is drawn in background or foreground.
3829 */
3830 BOOL sciGetGridFront(sciPointObj * pObj)
3831 {
3832     switch (sciGetEntityType(pObj))
3833     {
3834     case SCI_SUBWIN:
3835         return pSUBWIN_FEATURE(pObj)->gridFront;
3836     default:
3837         printSetGetErrorMessage("grid_position");
3838         return FALSE;
3839     }
3840 }
3841 /*----------------------------------------------------------------------------------*/
3842 /**
3843 * @return the number of pass used for antialiasing or 0 if antialiasing is disable.
3844 */
3845 int sciGetAntialiasingQuality(sciPointObj * pObj)
3846 {
3847     switch (sciGetEntityType(pObj))
3848     {
3849     case SCI_FIGURE:
3850         if (isFigureModel(pObj->UID))
3851         {
3852             return pFIGURE_FEATURE(pObj)->pModelData->antialiasingQuality;
3853         }
3854         else
3855         {
3856             return sciGetJavaAntialiasingQuality(pObj);
3857         }
3858     default:
3859         printSetGetErrorMessage("anti_aliasing");
3860         return FALSE;
3861     }
3862 }
3863 /*----------------------------------------------------------------------------------*/
3864 /**
3865 * Get the position of a legend object relative to its parent subwin
3866 */
3867 sciLegendPlace sciGetLegendLocation(sciPointObj * pObj)
3868 {
3869     switch (sciGetEntityType(pObj))
3870     {
3871     case SCI_LEGEND:
3872         return pLEGEND_FEATURE(pObj)->place;
3873     default:
3874         printSetGetErrorMessage("legend_location");
3875         return SCI_LEGEND_POSITION_UNSPECIFIED;
3876     }
3877 }
3878 /*----------------------------------------------------------------------------------*/
3879 /**
3880 * Print the message "This object has no xxx property." in Scilab.
3881 */
3882 void printSetGetErrorMessage(const char * propertyName)
3883 {
3884     Scierror(999, _("This object has no %s property.\n"), propertyName );
3885 }
3886 /*----------------------------------------------------------------------------------*/
3887