10b04a31a4a9c3aad028909898870a4932cb54be
[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 /**sciGetXorMode
1370 * Returns the drawing Xor mode
1371 * @param sciPointObj * pobj: the pointer to the entity
1372 * @return 0,1,... 15
1373 * @author Djalel ABDEMOUCHE
1374 * @see sciSetXorMode
1375 */
1376 int
1377 sciGetXorMode (sciPointObj * pobj)
1378 {
1379     switch (sciGetEntityType (pobj))
1380     {
1381     case SCI_FIGURE:
1382         return (sciGetGraphicMode (pobj))->xormode;
1383         break;
1384     case SCI_SUBWIN:
1385         /* the value is inhirated by the parent */
1386         return sciGetXorMode (sciGetParentFigure (pobj));
1387         break;
1388     case SCI_TEXT:
1389     case SCI_LEGEND:
1390     case SCI_ARC:
1391     case SCI_SEGS:
1392     case SCI_FEC:
1393     case SCI_GRAYPLOT:
1394     case SCI_POLYLINE:
1395     case SCI_RECTANGLE:
1396     case SCI_SURFACE:
1397     case SCI_AXES:
1398     case SCI_AGREG:
1399     case SCI_LABEL: /* F.Leray 28.05.04 */
1400     case SCI_UIMENU:
1401     default:
1402         printSetGetErrorMessage("graphic_mode");
1403         return FALSE;
1404         break;
1405     }
1406     return FALSE;
1407 }
1408
1409 /**
1410 * To know wether an object will be displayed on the screen or not.
1411 * Because if one of its parent is not visible then it won't be displayed.
1412 */
1413 BOOL
1414 sciGetRealVisibility (sciPointObj * pobj)
1415 {
1416
1417     if ( pobj == NULL )
1418     {
1419         return FALSE ;
1420     }
1421
1422     if ( sciGetEntityType( pobj ) == SCI_FIGURE )
1423     {
1424         return sciGetVisibility( pobj ) ;
1425     }
1426
1427     if ( !sciGetVisibility( pobj ) )
1428     {
1429         return FALSE ;
1430     }
1431
1432     return sciGetRealVisibility( sciGetParent( pobj ) ) ;
1433
1434 }
1435
1436 /**sciGetVisibility*/
1437 BOOL
1438 sciGetVisibility (sciPointObj * pobj)
1439 {
1440     int visible = 0;
1441     int* piVisible = &visible;
1442     getGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, jni_bool, &piVisible);
1443
1444     return visible;
1445 }
1446
1447
1448
1449 /**sciGetResize (replace sciGetwresize()in the next version)
1450 * Returns if this object is in autoresizing mode (when the window is resized by user)
1451 * @param sciPointObj * pobj: the pointer to the entity
1452 * @return TRUE if yes, FALSE if no
1453 */
1454 BOOL
1455 sciGetResize (sciPointObj * pobj)
1456 {
1457     switch (sciGetEntityType (pobj))
1458     {
1459     case SCI_FIGURE:
1460         if (isFigureModel(pobj->UID))
1461         {
1462             return pFIGURE_FEATURE(pobj)->pModelData->autoResizeMode;
1463         }
1464         else
1465         {
1466             return sciGetJavaAutoResizeMode(pobj);
1467         }
1468         break;
1469     case SCI_SUBWIN:
1470         /* the value is inhirated by the parent */
1471         return sciGetResize (sciGetParent (pobj));
1472         break;
1473     case SCI_TEXT:
1474     case SCI_LEGEND:
1475     case SCI_ARC:
1476     case SCI_SEGS:
1477     case SCI_FEC:
1478     case SCI_GRAYPLOT:
1479     case SCI_POLYLINE:
1480     case SCI_RECTANGLE:
1481     case SCI_SURFACE:
1482     case SCI_AXES:
1483     case SCI_AGREG:
1484     case SCI_LABEL: /* F.Leray 28.05.04 */
1485     case SCI_UIMENU:
1486     default:
1487         printSetGetErrorMessage("auto_resize");
1488         return FALSE;
1489         break;
1490     }
1491     return FALSE;
1492 }
1493
1494
1495 /**sciGetName
1496 * Returns the name of the Figure or SubWindow
1497 * @param sciPointObj * pobj: the pointer to the entity
1498 * @return the pointer to the char name
1499 */
1500 char *
1501 sciGetName (sciPointObj * pobj)
1502 {
1503     switch (sciGetEntityType (pobj))
1504     {
1505     case SCI_FIGURE:
1506         return pFIGURE_FEATURE (pobj)->name;
1507         break;
1508     case SCI_SUBWIN:
1509     case SCI_AGREG:
1510     default:
1511         printSetGetErrorMessage("figure_name");
1512         return NULL;
1513         break;
1514     }
1515 }
1516
1517 /**sciGetNum
1518 * Returns the number of the Figure.
1519 * @param sciPointObj * pobj: the pointer to the entity
1520 * @return the number of the windows contening this entity
1521 */
1522 int
1523 sciGetNum (sciPointObj * pobj)
1524 {
1525     int iFigureId = 0;
1526     int* piFigureId = &iFigureId;
1527
1528     getGraphicObjectProperty(pobj->UID, __GO_ID__, jni_int, &piFigureId);
1529
1530     if (piFigureId == NULL)
1531     {
1532         printSetGetErrorMessage("figure_id");
1533         return -1;
1534     }
1535
1536     return iFigureId;
1537
1538     /*
1539      * Deactivated for now.
1540      * The SUBWIN (Axes) case must be taken into account.
1541      * To be implemented using the MVC framework.
1542      */
1543 #if 0
1544     switch (sciGetEntityType (pobj))
1545     {
1546     case SCI_FIGURE:
1547         return pFIGURE_FEATURE (pobj)->number;
1548         break;
1549     case SCI_SUBWIN:
1550         return sciGetNum (sciGetParent(pobj));
1551         break;
1552     case SCI_AGREG:
1553     default:
1554         printSetGetErrorMessage("figure_id");
1555         return -1;
1556         break;
1557     }
1558 #endif
1559 }
1560
1561
1562 /**sciGetWidth
1563 * Returns the width in pixel of the figure or subwin
1564 * @param sciPointObj * pobj: the pointer to the entity
1565 * @return the width of the dimension of the window or figure
1566 * (the visibility dimension) in pixel dimension
1567 */
1568 int sciGetWidth (sciPointObj * pobj)
1569 {
1570     switch (sciGetEntityType (pobj))
1571     {
1572     case SCI_FIGURE:
1573         if ( pobj == getFigureModel() )
1574         {
1575             return pFIGURE_FEATURE(pobj)->pModelData->figureWidth;
1576         }
1577         else
1578         {
1579             int size[2] ;
1580             sciGetJavaFigureSize(pobj, size);
1581             return size[0];
1582         }
1583         break;
1584     default:
1585         printSetGetErrorMessage("width");
1586         return -1;
1587         break;
1588     }
1589 }
1590
1591
1592 /**sciGetHeight
1593 * Returns the height in pixel of the figure or subwin
1594 * @param sciPointObj * pobj: the pointer to the entity
1595 * @return the height of the dimension of the window or figure (the visibility dimension) in pixel dimension
1596 */
1597 int sciGetHeight (sciPointObj * pobj)
1598 {
1599     switch (sciGetEntityType (pobj))
1600     {
1601     case SCI_FIGURE:
1602         if ( pobj == getFigureModel() )
1603         {
1604             return pFIGURE_FEATURE(pobj)->pModelData->figureHeight;
1605         }
1606         else
1607         {
1608             int size[2] ;
1609             sciGetJavaFigureSize(pobj, size);
1610             return size[1];
1611         }
1612         break;
1613     default:
1614         printSetGetErrorMessage("height");
1615         return -1;
1616         break;
1617     }
1618 }
1619
1620 /**sciGetDim
1621 * Gets the dimension of the Figure or Subwin
1622 * @param sciPointObj * pobj: the pointer to the entity
1623 * @param int *pwidth: the return width of the window dimension
1624 * @param int *pheight: the return height of the window dimension
1625 */
1626 void sciGetDim( sciPointObj * pobj, int * pWidth, int * pHeight )
1627 {
1628     switch (sciGetEntityType (pobj))
1629     {
1630     case SCI_FIGURE:
1631         if ( pobj == getFigureModel() )
1632         {
1633             *pWidth  = pFIGURE_FEATURE(pobj)->pModelData->figureWidth ;
1634             *pHeight = pFIGURE_FEATURE(pobj)->pModelData->figureHeight;
1635         }
1636         else
1637         {
1638             int size[2] ;
1639             sciGetJavaFigureSize(pobj, size);
1640             *pWidth = size[0] ;
1641             *pHeight = size[1] ;
1642         }
1643         break;
1644     default:
1645         printSetGetErrorMessage("size");
1646         break;
1647     }
1648 }
1649
1650 /**
1651 * Get the size of the window enclosing a figure object
1652 */
1653 int sciGetWindowWidth(sciPointObj * pObj)
1654 {
1655     switch(sciGetEntityType(pObj))
1656     {
1657     case SCI_FIGURE:
1658         if ( pObj == getFigureModel() )
1659         {
1660             return pFIGURE_FEATURE(pObj)->pModelData->windowWidth ;
1661         }
1662         else
1663         {
1664             int size[2] ;
1665             sciGetJavaWindowSize(pObj, size) ;
1666             return size[0] ;
1667         }
1668         break;
1669     default:
1670         printSetGetErrorMessage("figure_size");
1671         break;
1672     }
1673     return -1;
1674 }
1675
1676
1677 int sciGetWindowHeight(sciPointObj * pObj)
1678 {
1679     switch(sciGetEntityType(pObj))
1680     {
1681     case SCI_FIGURE:
1682         if ( pObj == getFigureModel() )
1683         {
1684             return pFIGURE_FEATURE(pObj)->pModelData->windowHeight ;
1685         }
1686         else
1687         {
1688             int size[2] ;
1689             sciGetJavaWindowSize(pObj, size) ;
1690             return size[1] ;
1691         }
1692         break;
1693     default:
1694         printSetGetErrorMessage("figure_size");
1695         break;
1696     }
1697     return -1;
1698 }
1699
1700
1701 /**sciIsExistingSubWin
1702 * Determines if this SubWindow is an existing one in the current SCI_FIGURE
1703 * in association with the wrect and frect....
1704 * @param WRect: Window rectangle dimension in double,
1705 * @param FRect: window user's scale dimension in double,
1706 * @param logscale: flag for logarithmic window
1707 * @return the pointer to the existing SubWindow, or Null if no one is existing
1708 */
1709 sciPointObj *
1710 sciIsExistingSubWin (double WRect[4])
1711 {
1712
1713 // ???
1714 #if 0
1715     sciPointObj *pparentfigure;
1716     sciSons *psonstmp;
1717
1718     double WRectTmp[4];
1719     int i;
1720
1721
1722     /* Initialisation de WRectTmp a 0*/
1723     for(i=0;i<4;i++)
1724     {
1725         WRectTmp[i] = 0.0;
1726     }
1727
1728     pparentfigure = (sciPointObj *)sciGetCurrentFigure();
1729     if (pparentfigure == NULL)
1730     {
1731         return NULL;
1732     }
1733
1734     /**  15/03/2002 **/
1735     if ((WRect[0] == 0.)&&(WRect[1] == 0.)&&(WRect[2] == 1.)&&(WRect[3] == 1.))
1736     {
1737         /* return the last subwindow */
1738         sciSons * curSon = sciGetLastSons(pparentfigure);
1739         while (sciGetEntityType(curSon->pointobj) != SCI_SUBWIN)
1740         {
1741             curSon = curSon->pprev;
1742         }
1743         return curSon->pointobj;
1744     }
1745
1746     psonstmp = sciGetSons (pparentfigure);
1747     while (psonstmp != NULL)
1748     {
1749         sciPointObj * curObj = psonstmp->pointobj;
1750         if (sciGetEntityType (curObj) == SCI_SUBWIN)
1751         {
1752             WRectTmp[0] = pSUBWIN_FEATURE (curObj)->WRect[0];
1753             WRectTmp[1] = pSUBWIN_FEATURE (curObj)->WRect[1];
1754             WRectTmp[2] = pSUBWIN_FEATURE (curObj)->WRect[2];
1755             WRectTmp[3] = pSUBWIN_FEATURE (curObj)->WRect[3];
1756
1757             if (   (Abs(WRectTmp[0] - WRect[0]) < 1e-8)
1758                 && (Abs(WRectTmp[1] - WRect[1]) < 1e-8)
1759                 && (Abs(WRectTmp[2] - WRect[2]) < 1e-8)
1760                 && (Abs(WRectTmp[3] - WRect[3]) < 1e-8))
1761             {
1762                 /* subwin found */
1763                 return curObj;
1764             }
1765         }
1766         psonstmp = psonstmp->pnext;
1767     }
1768
1769 #endif
1770     return NULL;
1771 }
1772
1773 /*--------------------------------------------------------------------------*/
1774
1775
1776 /**sciGetPoint
1777 * 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
1778 */
1779
1780 /**MAJ pour le 3D DJ.Abdemouche 2003**/
1781 double *sciGetPoint(char * pthis, int *numrow, int *numcol)
1782 {
1783     char* type;
1784     double *tab;
1785     int i,k;
1786
1787     getGraphicObjectProperty(pthis, __GO_TYPE__, jni_string, &type);
1788
1789     /*
1790      * Object type determined by string comparisons
1791      * Required as we have no better way to do this for the moment
1792      */
1793     if (strcmp(type, __GO_FIGURE__) == 0)
1794     {
1795         int* figurePosition;
1796         int* axesSize;
1797
1798         *numrow = 2;
1799         *numcol = 2;
1800         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1801         {
1802             *numrow = -1;
1803             *numcol = -1;
1804             return NULL;
1805         }
1806
1807         getGraphicObjectProperty(pthis, __GO_POSITION__, jni_int_vector, &figurePosition);
1808         getGraphicObjectProperty(pthis, __GO_AXES_SIZE__, jni_int_vector, &axesSize);
1809
1810         tab[0] = (double) figurePosition[0];
1811         tab[1] = (double) figurePosition[1];
1812         tab[2] = (double) axesSize[0];
1813         tab[3] = (double) axesSize[1];
1814
1815         return tab;
1816     }
1817     else if (strcmp(type, __GO_POLYLINE__) == 0)
1818     {
1819         char* parentAxes;
1820         double* dataX = NULL;
1821         double* dataY = NULL;
1822         double* dataZ = NULL;
1823         int iTmp = 0;
1824         int* piTmp = &iTmp;
1825         int iView =0;
1826         int *piView = &iView;
1827
1828         /*
1829          * Testing whether data properties exist for this object
1830          * is currently done only for this property. The type comparison already
1831          * ensures that this is the case, though doing so is awkward.
1832          */
1833         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_ELEMENTS__, jni_int, &piTmp);
1834
1835         if (piTmp == NULL)
1836         {
1837             *numrow = -2;
1838             *numcol = -2;
1839             return NULL;
1840         }
1841
1842         *numrow = iTmp;
1843
1844         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z_COORDINATES_SET__, jni_int, &piTmp);
1845
1846         if (iTmp)
1847         {
1848             *numcol = 3;
1849         }
1850         else
1851         {
1852             *numcol = 2;
1853         }
1854
1855         if ( (*numrow)*(*numcol) == 0 )
1856         {
1857             /* empty data, no warnings */
1858             *numrow = 0;
1859             *numcol = 0;
1860             return NULL;
1861         }
1862
1863         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1864         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1865
1866         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, jni_double_vector, &dataX);
1867         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, jni_double_vector, &dataY);
1868
1869         if (*numcol == 2 && iView)
1870         {
1871             *numcol = (*numcol)+1; /* colonne de 0. a prendre en compte / afficher => numcol+1*/
1872             if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1873             {
1874                 *numrow = -1;
1875                 *numcol = -1;
1876                 return NULL;
1877             }
1878
1879             for ( i = 0 ; i < *numrow ; i++ )
1880             {
1881                 tab[i] = dataX[i];
1882                 tab[*numrow+i]= dataY[i];
1883                 tab[(2*(*numrow))+i]= 0.;
1884             }
1885         }
1886         else
1887         {
1888             if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1889             {
1890                 *numrow = -1;
1891                 *numcol = -1;
1892                 return NULL;
1893             }
1894
1895             if (*numcol == 3)
1896             {
1897                 getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, jni_double_vector, &dataZ);
1898             }
1899
1900             for ( i = 0 ; i < *numrow ; i++ )
1901             {
1902                 tab[i] = dataX[i];
1903                 tab[*numrow+i]= dataY[i];
1904                 if (*numcol== 3)
1905                 {
1906                     tab[(2*(*numrow))+i] = dataZ[i];
1907                 }
1908             }
1909
1910         }
1911         return tab;
1912     }
1913     else if (strcmp(type, __GO_RECTANGLE__) == 0)
1914     {
1915         char* parentAxes;
1916         double* upperLeftPoint;
1917         double* tmpDouble;
1918         double width = 0.0;
1919         double *pdblWidth = &width;
1920         double height = 0.0;
1921         double *pdblHeight = &height;
1922         int* tmp;
1923         int iView = 0;
1924         int *piView = &iView;
1925
1926         *numrow = 1;
1927
1928         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1929         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1930
1931         *numcol = iView ? 5: 4;
1932
1933         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1934         {
1935             *numrow = -1;
1936             *numcol = -1;
1937             return NULL;
1938         }
1939
1940         getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &upperLeftPoint);
1941
1942         getGraphicObjectProperty(pthis, __GO_WIDTH__, jni_double, &pdblWidth);
1943         getGraphicObjectProperty(pthis, __GO_HEIGHT__, jni_double, &pdblHeight);
1944
1945         tab[0] = upperLeftPoint[0];
1946         tab[1] = upperLeftPoint[1];
1947
1948         if (iView)
1949         {
1950             tab[2] = upperLeftPoint[2];
1951             tab[3] = width;
1952             tab[4] = height;
1953         }
1954         else
1955         {
1956             tab[2] = width;
1957             tab[3] = height;
1958         }
1959         return (double*)tab;
1960     }
1961     else if (strcmp(type, __GO_ARC__) == 0)
1962     {
1963         char* parentAxes;
1964         double* upperLeftPoint;
1965         double* tmpDouble;
1966         double width = 0.0;
1967         double *pdblWidth = &width;
1968
1969         double height;
1970         double *pdblHeight = &height;
1971
1972         double startAngle;
1973         double *pdblStartAngle = &startAngle;
1974         double endAngle;
1975         double *pdblEndAngle = &endAngle;
1976         int* tmp;
1977         int view = 0;
1978         int *piView = &view;
1979
1980         *numrow = 1;
1981
1982         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
1983         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
1984
1985         *numcol = view ? 7: 6;
1986
1987         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
1988         {
1989             *numrow = -1;
1990             *numcol = -1;
1991             return NULL;
1992         }
1993
1994         getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &upperLeftPoint);
1995
1996         getGraphicObjectProperty(pthis, __GO_WIDTH__, jni_double, &pdblWidth);
1997         getGraphicObjectProperty(pthis, __GO_HEIGHT__, jni_double, &pdblHeight);
1998
1999         getGraphicObjectProperty(pthis, __GO_START_ANGLE__, jni_double, &pdblStartAngle);
2000         getGraphicObjectProperty(pthis, __GO_END_ANGLE__, jni_double, &pdblEndAngle);
2001
2002         tab[0] = upperLeftPoint[0];
2003         tab[1] = upperLeftPoint[1];
2004
2005         if (view)
2006         {
2007             tab[2] = upperLeftPoint[2];
2008             tab[3] = width;
2009             tab[4] = height;
2010             tab[5] = RAD2DEG(startAngle);
2011             tab[6] = RAD2DEG(endAngle);
2012         }
2013         else
2014         {
2015             tab[2] = width;
2016             tab[3] = height;
2017             tab[4] = RAD2DEG(startAngle);
2018             tab[5] = RAD2DEG(endAngle);
2019         }
2020
2021         return (double*)tab;
2022     }
2023     else if (strcmp(type, __GO_COMPOUND__) == 0)
2024     {
2025         return (double*)NULL;
2026     }
2027     else if (strcmp(type, __GO_TEXT__) == 0)
2028     {
2029         char* parentAxes;
2030         double* textPosition;
2031         int iView = 0;
2032         int* piView = &iView;
2033
2034         *numrow = 1;
2035
2036         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
2037         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
2038
2039         *numcol = iView ? 3: 2;
2040
2041         if ((tab = CALLOC((*numrow)*(*numcol),sizeof(double))) == NULL)
2042         {
2043             *numrow = -1;
2044             *numcol = -1;
2045             return NULL;
2046         }
2047
2048         getGraphicObjectProperty(pthis, __GO_POSITION__, jni_double_vector, &textPosition);
2049
2050         tab[0] = textPosition[0];
2051         tab[1] = textPosition[1];
2052
2053         if (iView)
2054         {
2055             tab[2] = textPosition[2];
2056         }
2057
2058         return (double*)tab;
2059     }
2060     else if (strcmp(type, __GO_SEGS__) == 0)
2061     {
2062         int iView = 0;
2063         int* piView = &iView;
2064         int iNumArrows = 0;
2065         int* piNumArrows = &iNumArrows;
2066         char* parentAxes;
2067         double* arrowBases;
2068         double* arrowDirections;
2069
2070         getGraphicObjectProperty(pthis, __GO_NUMBER_ARROWS__, jni_int, &piNumArrows);
2071         *numrow = iNumArrows;
2072
2073         /* only two coordinates are displayed if the axe is in 2d
2074         and the z coordinates has never been modified */
2075
2076         getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
2077
2078         getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
2079
2080         if (iView)
2081         {
2082             *numcol = 3;
2083         }
2084         else
2085         {
2086             *numcol = 2;
2087         }
2088
2089         if ((tab = CALLOC(2*(*numrow)*(*numcol),sizeof(double))) == NULL)
2090         {
2091             *numrow = -1;
2092             *numcol = -1;
2093             return NULL;
2094         }
2095
2096         getGraphicObjectProperty(pthis, __GO_BASE__, jni_double_vector, &arrowBases);
2097         getGraphicObjectProperty(pthis, __GO_DIRECTION__, jni_double_vector, &arrowDirections);
2098
2099         for (i = 0; i < *numrow; i++)
2100         {
2101             tab[2*i] = arrowBases[3*i];
2102             tab[2*i+1] = arrowDirections[3*i];
2103             tab[2*(*numrow)+2*i] = arrowBases[3*i+1];
2104             tab[2*(*numrow)+2*i+1] = arrowDirections[3*i+1];
2105
2106             if (iView)
2107             {
2108                 tab[4*(*numrow)+2*i] = arrowBases[3*i+2];
2109                 tab[4*(*numrow)+2*i+1] = arrowDirections[3*i+2];
2110             }
2111         }
2112
2113         /* There are twice as many points as arrows (2 endpoints) */
2114         *numrow = 2*(*numrow);
2115
2116         return (double*)tab;
2117     }
2118     else if (strcmp(type, __GO_FAC3D__) == 0)
2119     {
2120         *numrow = -1;
2121         *numcol = -1;
2122         return (double*) NULL;
2123     }
2124     else if (strcmp(type, __GO_PLOT3D__) == 0)
2125     {
2126         *numrow = -1;
2127         *numcol = -1;
2128         return (double*) NULL;
2129     }
2130     else if (strcmp(type, __GO_MATPLOT__) == 0)
2131     {
2132         int* tmp;
2133         int nx = 0;
2134         int *piNx = &nx;
2135         int ny = 0;
2136         int *piNy = &ny;
2137         double* data;
2138
2139         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_X__, jni_int, &piNx);
2140
2141         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_Y__, jni_int, &piNy);
2142
2143         /* The z data matrix has (ny-1) rows and (nx-1) cols */
2144         nx = nx - 1;
2145         ny = ny - 1;
2146
2147         *numrow = ny;
2148         *numcol = nx;
2149
2150         if ((tab = CALLOC(nx*ny,sizeof(double))) == NULL)
2151         {
2152             *numrow = -1;
2153             *numcol = -1;
2154             return (double*)NULL;
2155         }
2156
2157         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, jni_double_vector, &data);
2158
2159         for (i=0; i < nx*ny; i++)
2160         {
2161             tab[i] = data[i];
2162         }
2163
2164         return (double*)tab;
2165     }
2166     else if (strcmp(type, __GO_FEC__) == 0)
2167     {
2168         double* coordinates;
2169         double* values;
2170         int iTmp = 0;
2171         int* piTmp = &iTmp;
2172
2173         *numcol = 3;
2174
2175         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_VERTICES__, jni_int, &piTmp);
2176         *numrow = iTmp;
2177
2178         if ((tab = CALLOC(*numrow * 3,sizeof(double))) == NULL)
2179         {
2180             *numrow = -1;
2181             *numcol = -1;
2182             return (double*)NULL;
2183         }
2184
2185         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_COORDINATES__, jni_double_vector, &coordinates);
2186         getGraphicObjectProperty(pthis, __GO_DATA_MODEL_VALUES__, jni_double_vector, &values);
2187
2188         for (i=0;i < *numrow;i++)
2189         {
2190             tab[i] = coordinates[3*i];
2191             tab[*numrow+i] = coordinates[3*i+1];
2192             tab[*numrow*2+i] = values[i];
2193
2194         }
2195
2196         return (double*)tab;
2197     }
2198     else if (strcmp(type, __GO_LEGEND__) == 0)
2199     {
2200         *numrow = -2;
2201         *numcol = -2;
2202         return (double*)NULL;
2203     }
2204     else if (strcmp(type, __GO_AXES__) == 0)
2205     {
2206         *numrow = -2;
2207         *numcol = -2;
2208         return (double*)NULL;
2209     }
2210     /* F.Leray 28.05.04 */
2211     else if (strcmp(type, __GO_LABEL__) == 0)
2212     {
2213         *numrow = -2;
2214         *numcol = -2;
2215         return (double*)NULL;
2216     }
2217     else
2218     {
2219         *numrow = -2;
2220         *numcol = -2;
2221         return (double*)NULL;
2222     }
2223
2224     /*
2225      * Deactivated for now
2226      * Same as the else condition
2227      */
2228 #if 0
2229     case SCI_UIMENU:
2230 #endif
2231     return (double*)NULL;
2232 }
2233
2234
2235 BOOL
2236 sciGetdrawmode (sciPointObj *pobj)
2237 {
2238     static sciPointObj *subwin;
2239
2240     subwin= (sciPointObj *) sciGetParentSubwin (pobj);
2241     if  (subwin != (sciPointObj *) NULL)
2242         return pSUBWIN_FEATURE(subwin)->visible ;
2243     return FALSE;
2244 }
2245
2246 /**sciGetAxes
2247 * Gets SUBWIN of this Scilab graphic figure
2248 * @author Djalel ABDEMOUCHE
2249 */
2250 sciPointObj *
2251 sciGetAxes (sciPointObj *pparentfigure,sciPointObj *psubwin)
2252 {
2253     sciSons *psonstmp;
2254
2255     psonstmp = sciGetSons (pparentfigure);
2256
2257
2258     if (psonstmp != (sciSons *) NULL)
2259     {
2260         /* tant que le fils ne corespond pas a l'entite */
2261         while ((psonstmp->pnext  != (sciSons *) NULL)
2262             && (sciGetEntityType (psonstmp->pointobj) != SCI_SUBWIN))
2263             psonstmp = psonstmp->pnext;
2264
2265         if  (psonstmp->pnext  == (sciSons *) NULL)
2266             return (sciPointObj *) NULL;
2267         else
2268             if (sciGetEntityType (psonstmp->pointobj) == SCI_SUBWIN)
2269                 return (sciPointObj *)psonstmp->pointobj;
2270             else
2271                 return (sciPointObj *) NULL; /* added SS ????*/
2272     }
2273     else
2274         return (sciPointObj *) NULL;
2275 }
2276
2277 /**sciGetPointerToToUserData
2278 * Returns the pointer to the user_data and size_of_user_data fields associated with
2279 the pobj object
2280 */
2281 void sciGetPointerToUserData (sciPointObj * pobj,int ***user_data_ptr, int **size_ptr)
2282 {
2283
2284     /* perhaps is it necessary to cast the returns value with void* type ! */
2285     switch (sciGetEntityType (pobj))
2286     {
2287     case SCI_FIGURE:
2288         *user_data_ptr = &(((sciFigure *) pFIGURE_FEATURE (pobj))->user_data);
2289         *size_ptr=&(((sciFigure *) pFIGURE_FEATURE (pobj))->size_of_user_data);
2290         break;
2291     case SCI_SUBWIN:
2292         *user_data_ptr = &(((sciSubWindow *) pSUBWIN_FEATURE (pobj))->user_data);
2293         *size_ptr =  &(((sciSubWindow *) pSUBWIN_FEATURE (pobj))->size_of_user_data);
2294         break;
2295     case SCI_TEXT:
2296         *user_data_ptr = &(((sciText *) pTEXT_FEATURE (pobj))->user_data);
2297         *size_ptr =  &(((sciText *) pTEXT_FEATURE (pobj))->size_of_user_data);
2298         break;
2299     case SCI_LEGEND:
2300         *user_data_ptr = &(((sciLegend *) pLEGEND_FEATURE (pobj))->user_data);
2301         *size_ptr =  &(((sciLegend *) pLEGEND_FEATURE (pobj))->size_of_user_data);
2302         break;
2303     case SCI_ARC:
2304         *user_data_ptr = &(((sciArc *) pARC_FEATURE (pobj))->user_data);
2305         *size_ptr = &(((sciArc *) pARC_FEATURE (pobj))->size_of_user_data);
2306         break;
2307     case SCI_POLYLINE:
2308         *user_data_ptr = &(((sciPolyline *) pPOLYLINE_FEATURE (pobj))->user_data);
2309         *size_ptr =  &(((sciPolyline *) pPOLYLINE_FEATURE (pobj))->size_of_user_data);
2310         break;
2311     case SCI_SEGS:
2312         *user_data_ptr = &(((sciSegs *) pSEGS_FEATURE (pobj))->user_data);
2313         *size_ptr = &(((sciSegs *) pSEGS_FEATURE (pobj))->size_of_user_data );
2314         break;
2315     case SCI_FEC:
2316         *user_data_ptr = &(((sciFec *) pFEC_FEATURE (pobj))->user_data);
2317         *size_ptr =  &(((sciFec *) pFEC_FEATURE (pobj))->size_of_user_data) ;
2318         break;
2319     case SCI_GRAYPLOT:
2320         *user_data_ptr = &(((sciGrayplot *) pGRAYPLOT_FEATURE (pobj))->user_data);
2321         *size_ptr =  &(((sciGrayplot *) pGRAYPLOT_FEATURE (pobj))->size_of_user_data);
2322         break;
2323     case SCI_RECTANGLE:
2324         *user_data_ptr = &(((sciRectangle *) pRECTANGLE_FEATURE (pobj))->user_data);
2325         *size_ptr =  &(((sciRectangle *) pRECTANGLE_FEATURE (pobj))->size_of_user_data);
2326         break;
2327     case SCI_SURFACE:
2328         *user_data_ptr = &(((sciSurface *) pSURFACE_FEATURE (pobj))->user_data);
2329         *size_ptr =  &(((sciSurface *) pSURFACE_FEATURE (pobj))->size_of_user_data);
2330         break;
2331     case SCI_AXES:
2332         *user_data_ptr = &(((sciAxes *) pAXES_FEATURE (pobj))->user_data);
2333         *size_ptr =  &(((sciAxes *) pAXES_FEATURE (pobj))->size_of_user_data);
2334         break;
2335     case SCI_AGREG:
2336         *user_data_ptr = &(((sciAgreg *) pAGREG_FEATURE (pobj))->user_data);
2337         *size_ptr =  &(((sciAgreg *) pAGREG_FEATURE (pobj))->size_of_user_data);
2338         break;
2339     case SCI_LABEL:
2340         sciGetPointerToUserData ( pLABEL_FEATURE(pobj)->text, user_data_ptr, size_ptr ) ;
2341         break;
2342     case SCI_UIMENU:
2343         *user_data_ptr = &(pUIMENU_FEATURE (pobj)->user_data);
2344         *size_ptr=&(pUIMENU_FEATURE (pobj)->size_of_user_data);
2345         break;
2346     case SCI_UICONTROL:
2347         *user_data_ptr = &(pUICONTROL_FEATURE (pobj)->user_data);
2348         *size_ptr=&(pUICONTROL_FEATURE (pobj)->size_of_user_data);
2349         break;
2350     default:
2351         *user_data_ptr = (int **)NULL;
2352         *size_ptr =   (int *)NULL;
2353         break;
2354     }
2355 }
2356
2357
2358 /**
2359 * Don't use this ugly function !!!! (Jb Silvy)
2360 * 130 strcmp to know the type of a parameter
2361 */
2362 int sciType (char *marker,sciPointObj * pobj)
2363 {
2364     if      (strcmp(marker,"arrow_size_factor") == 0) { return sci_matrix;}
2365     else if (strcmp(marker,"x_shift") == 0) { return sci_matrix;}
2366     else if (strcmp(marker,"y_shift") == 0) { return sci_matrix;}
2367     else if (strcmp(marker,"z_shift") == 0) { return sci_matrix;}
2368     else if (strcmp(marker,"bar_width") == 0) { return sci_matrix;}
2369     else if (strcmp(marker,"closed") == 0) { return sci_strings;}
2370     else if (strcmp(marker,"label") == 0) { return sci_strings;}
2371     else if (strcmp(marker,"callback") == 0) { return sci_strings;}
2372     else if (strcmp(marker,"background") == 0) { return sci_matrix;}
2373     else if (strcmp(marker,"position") == 0) {return sci_matrix;}
2374     else if (strcmp(marker,"auto_position") == 0)   {return sci_strings;}
2375     else if (strcmp(marker,"auto_rotation") == 0)   {return sci_strings;}
2376     else if (strcmp(marker,"interp_color_vector") == 0) {return sci_matrix;}
2377     else if (strcmp(marker,"interp_color_mode") == 0) {return sci_strings;}
2378     else if (strcmp(marker,"foreground") == 0) {return sci_matrix;}
2379     else if (strcmp(marker,"thickness") == 0)   {return sci_matrix;}
2380     else if (strcmp(marker,"line_style") == 0) {return sci_matrix;}
2381     else if (strcmp(marker,"line_mode") == 0) {return sci_strings;}
2382     else if (strcmp(marker,"fill_mode") == 0) {return sci_strings;}
2383     else if (strcmp(marker,"surface_mode") == 0) {return sci_strings;}
2384     else if (strcmp(marker,"mark_style") == 0) {return sci_matrix;}
2385     else if (strcmp(marker,"mark_size") == 0) {return sci_matrix;}
2386     else if (strcmp(marker,"mark_size_unit") == 0) {return sci_strings;}
2387     else if (strcmp(marker,"mark_mode") == 0)   {return sci_strings;}
2388     else if (strcmp(marker,"mark_foreground") == 0)   {return sci_matrix;}
2389     else if (strcmp(marker,"mark_background") == 0)   {return sci_matrix;}
2390     else if (strcmp(marker,"figure_position") == 0) {return sci_matrix;}
2391     else if (strcmp(marker,"axes_size") == 0)   {return sci_matrix;}
2392     else if (strcmp(marker,"axes_visible") == 0)   {return sci_strings;}
2393     else if (strcmp(marker,"hiddencolor") == 0)   {return 1;}/* DJ.A 2003 */
2394     else if (strcmp(marker,"isoview") == 0)   {return sci_strings;}/**DJ.Abdemouche 2003**/
2395     else if (strcmp(marker,"view") == 0)   {return sci_strings;}/**DJ.Abdemouche 2003**/
2396     else if (strcmp(marker,"figure_size") == 0){return sci_matrix;}
2397     else if (strcmp(marker,"figure_id") == 0)   {return sci_matrix;}
2398     else if (strcmp(marker,"figure_name") == 0){return sci_strings;}
2399     else if (strcmp(marker,"figures_id") == 0)   {return sci_matrix;}
2400     else if (strcmp(marker,"pixmap") == 0)   {return sci_strings;}/*Ajout A.Djalel*/
2401     else if (strcmp(marker,"polyline_style") == 0){return sci_matrix;}
2402     else if (strcmp(marker,"font_size") == 0)   {return sci_matrix;}
2403     else if (strcmp(marker,"font_angle") == 0) {return sci_matrix;}
2404     else if (strcmp(marker,"font_foreground") == 0){return sci_matrix;}
2405     else if (strcmp(marker,"font_color") == 0)   {return sci_matrix;} /* F.Leray 09.04.04 : Adding to support font_color user interface */
2406     else if (strcmp(marker,"font_style") == 0) {return sci_matrix;}
2407     else if (strcmp(marker,"font_name") == 0)   {return sci_strings;}
2408     else if (strcmp(marker,"textcolor"          ) == 0) {return sci_matrix;}
2409     else if (strcmp(marker,"labels_font_size"   ) == 0) {return sci_matrix;}
2410     else if (strcmp(marker,"labels_font_color"  ) == 0) {return sci_matrix;}
2411     else if (strcmp(marker,"text"               ) == 0) {return sci_strings;}
2412     else if (strcmp(marker,"text_box"           ) == 0) {return sci_matrix;}
2413     else if (strcmp(marker,"text_box_mode"      ) == 0) {return sci_strings;}
2414     else if (strcmp(marker,"old_style"          ) == 0) {return sci_strings;}
2415     else if (strcmp(marker,"figure_style"       ) == 0) {return sci_strings;}
2416     else if (strcmp(marker,"visible"            ) == 0) {return sci_strings;}
2417     else if (strcmp(marker,"auto_resize"        ) == 0) {return sci_strings;}
2418     else if (strcmp(marker,"pixel_drawing_mode" ) == 0) {return sci_strings;}
2419     else if (strcmp(marker,"default_values"     ) == 0) {return sci_matrix ;}
2420     else if (strcmp(marker,"color_map"          ) == 0) {return sci_matrix ;}
2421     else if (strcmp(marker,"x_location"         ) == 0) {return sci_strings;}
2422     else if (strcmp(marker,"y_location"         ) == 0) {return sci_strings;}
2423     else if (strcmp(marker,"tics_direction"     ) == 0) {return sci_strings;}
2424     else if (strcmp(marker,"tight_limits"       ) == 0) {return sci_strings;}
2425     else if (strcmp(marker,"box"                ) == 0) {return sci_strings;}
2426     else if (strcmp(marker,"tics_color"         ) == 0) {return sci_matrix ;}
2427     else if (strcmp(marker,"tics_textcolor"     ) == 0) {return sci_matrix ;}
2428     else if (strcmp(marker,"tics_textsize"      ) == 0) {return sci_matrix ;}
2429     else if (strcmp(marker,"xtics_coord"        ) == 0) {return sci_matrix ;}
2430     else if (strcmp(marker,"ytics_coord"        ) == 0) {return sci_matrix ;}
2431     else if (strcmp(marker,"grid"               ) == 0) {return sci_matrix ;}
2432     else if (strcmp(marker,"tics_segment"       ) == 0) {return sci_strings;}
2433     else if (strcmp(marker,"tics_style"         ) == 0) {return sci_strings;}
2434     else if (strcmp(marker,"format_n"           ) == 0) {return sci_strings;}
2435     else if (strcmp(marker,"tics_labels"        ) == 0) {return sci_strings;}
2436     else if (strcmp(marker,"sub_tics"           ) == 0) {return sci_matrix;}
2437     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*/
2438     else if (strcmp(marker,"zoom_box"           ) == 0) {return sci_matrix;}
2439     else if (strcmp(marker,"zoom_state"         ) == 0) {return sci_strings;}
2440     else if (strcmp(marker,"clip_box"           ) == 0) {return sci_matrix;}
2441     else if (strcmp(marker,"clip_state"         ) == 0) {return sci_strings;}
2442     else if (strcmp(marker,"auto_clear"         ) == 0) {return sci_strings;}
2443     else if (strcmp(marker,"auto_scale"         ) == 0) {return sci_strings;}
2444     else if (strcmp(marker,"arrow_size"         ) == 0) {return sci_matrix;}
2445     else if (strcmp(marker,"segs_color"         ) == 0) {return sci_matrix;}
2446     else if (strcmp(marker,"colored"            ) == 0) {return sci_strings;}
2447     else if (strcmp(marker,"data"               ) == 0)
2448         if((sciGetEntityType(pobj) == SCI_SURFACE) ||
2449             (sciGetEntityType(pobj) == SCI_SEGS     && pSEGS_FEATURE(pobj)->ptype == 1) || /* a champ */
2450             (sciGetEntityType(pobj) == SCI_GRAYPLOT && pGRAYPLOT_FEATURE(pobj)->type == 0))    /* a grayplot (case == 0) */
2451             return sci_tlist;
2452         else
2453             return 1;
2454     else if (strcmp(marker,"hdl"                ) == 0) {return sci_matrix;}
2455     else if (strcmp(marker,"callbackmevent"     ) == 0) {return sci_matrix;}
2456     else if (strcmp(marker,"callback"           ) == 0) {return sci_strings;}
2457     else if (strcmp(marker,"log_flags"          ) == 0) {return sci_strings;}
2458     else if (strcmp(marker,"data_mapping"       ) == 0) {return sci_strings;}
2459     else if (strcmp(marker,"surface_color"      ) == 0) {return sci_matrix;}
2460     else if (strcmp(marker,"rotation_angles"    ) == 0) {return sci_matrix;}
2461     else if (strcmp(marker,"color_mode"         ) == 0) {return sci_matrix;}/*DJ.A merge*/
2462     else if (strcmp(marker,"color_flag"         ) == 0) {return sci_matrix;}
2463     else if (strcmp(marker,"cdata_mapping"      ) == 0) {return sci_strings;}
2464     else if (strcmp(marker,"axes_bounds"        ) == 0) {return sci_matrix;}
2465     else if (strcmp(marker,"data_bounds"        ) == 0) {return sci_matrix;}
2466     else if (strcmp(marker,"margins"            ) == 0) {return sci_matrix;}
2467     else if (strcmp(marker,"surface_color"      ) == 0) {return sci_matrix;}
2468     else if (strcmp(marker,"rotation_style"     ) == 0) {return sci_strings;}
2469     else if (strcmp(marker,"triangles"          ) == 0) {return sci_matrix;}
2470     else if (strcmp(marker,"z_bounds"           ) == 0) {return sci_matrix;}
2471     else if (strcmp(marker,"current_axes"       ) == 0) {return sci_handles;}
2472     else if (strcmp(marker,"current_figure"     ) == 0) {return sci_handles;}
2473     else if (strcmp(marker,"current_obj"        ) == 0) {return sci_handles;}
2474     else if (strcmp(marker,"current_entity"     ) == 0) {return sci_handles;}
2475     else if (strcmp(marker,"default_axes"       ) == 0) {return sci_handles;}/* DJ.A 08/01/04 */
2476     else if (strcmp(marker,"default_figure"     ) == 0) {return sci_handles;}/* DJ.A 08/01/04 */
2477     else if (strcmp(marker,"children"           ) == 0) {return sci_handles;}
2478     else if (strcmp(marker,"cube_scaling"       ) == 0) {return sci_strings;} /* F.Leray 22.04.04 */
2479     else if (strcmp(marker,"x_label"            ) == 0) {return sci_handles;}  /* F.Leray 27.05.04 */
2480     else if (strcmp(marker,"y_label"            ) == 0) {return sci_handles;}
2481     else if (strcmp(marker,"z_label"            ) == 0) {return sci_handles;}
2482     else if (strcmp(marker,"title"              ) == 0) {return sci_handles;}
2483     else if (strcmp(marker,"x_ticks"            ) == 0) {return sci_tlist;}
2484     else if (strcmp(marker,"y_ticks"            ) == 0) {return sci_tlist;}
2485     else if (strcmp(marker,"z_ticks"            ) == 0) {return sci_tlist;}
2486     else if (strcmp(marker,"auto_ticks"         ) == 0) {return sci_strings;}
2487     else if (strcmp(marker,"axes_reverse"       ) == 0) {return sci_strings;}
2488     else if (strcmp(marker,"immediate_drawing"  ) == 0) {return sci_strings;}
2489     else if (strcmp(marker,"handle_visible"     ) == 0) {return sci_strings;}
2490     else if (strcmp(marker,"enable"             ) == 0) {return sci_strings;}
2491     else if (strcmp(marker,"callback_type"      ) == 0) {return sci_strings;}
2492     else if (strcmp(marker,"bounding_rect"      ) == 0) {return sci_matrix;} /*JBS 16/11/05 */
2493     else if (strcmp(marker,"hidden_axis_color"  ) == 0) {return sci_matrix;} /*       03/06 */
2494     else if (strcmp(marker,"alignment"          ) == 0) {return sci_strings;} /*       05/06 */
2495     else if (strcmp(marker,"viewport"           ) == 0) {return sci_matrix;} /*       01/07 */
2496     else if (strcmp(marker,"info_message"       ) == 0) {return sci_strings;} /*       01/07 */
2497     else {return -1;}
2498 }
2499 /*-------------------------------------------------------------------------------*/
2500 /**
2501 * Return the first surface found within the descendant of the object.
2502 * @param[in] psubwin Object from which the surface will be searched.
2503 * @return The first surface object if found, NULL otherwise.
2504 */
2505 sciPointObj * sciGetSurface( sciPointObj * pObj )
2506 {
2507     sciSons * psonstmp;
2508     sciPointObj * sonSurface = NULL ;
2509
2510     psonstmp = sciGetSons( pObj ) ;
2511     while ( psonstmp != NULL )
2512     {
2513         if( sciGetEntityType( psonstmp->pointobj ) == SCI_SURFACE )
2514         {
2515             /* We found one, return it.*/
2516             return psonstmp->pointobj ;
2517         }
2518         /* check the sons of this children */
2519         sonSurface = sciGetSurface( psonstmp->pointobj ) ;
2520         if ( sonSurface != NULL )
2521         {
2522             return sonSurface ;
2523         }
2524         psonstmp = psonstmp->pnext;
2525     }
2526     /* nothing has been found */
2527     return NULL;
2528 }
2529
2530 /**sciGetOriginalSubWin
2531 * PRIVATE.
2532 * @param sciPointObj * pfigure: the pointer to the parent figure
2533 * @return the pointer of the original subwindow
2534 */
2535 sciPointObj *
2536 sciGetOriginalSubWin (sciPointObj * pfigure)
2537 {
2538     return (sciPointObj *)pFIGURE_FEATURE(pfigure)->originalsubwin0011;
2539 }
2540
2541
2542 /* get the property of the axes box */
2543 EAxesBoxType sciGetBoxType( sciPointObj * pobj )
2544 {
2545     switch (sciGetEntityType (pobj))
2546     {
2547     case SCI_SUBWIN:
2548         return pSUBWIN_FEATURE(pobj)->axes.rect ;
2549     default:
2550         printSetGetErrorMessage("box_type");
2551         return (EAxesBoxType)0 ;
2552     }
2553     return (EAxesBoxType)0;
2554 }
2555
2556
2557 /**sciGetIsBoxed
2558 * Returns the box existence
2559 */
2560 BOOL
2561 sciGetIsBoxed (sciPointObj * pobj)
2562 {
2563     switch (sciGetEntityType (pobj))
2564     {
2565     case SCI_TEXT:
2566         return pTEXT_FEATURE(pobj)->isboxed;
2567         break;
2568     case SCI_SUBWIN:
2569         return ( pSUBWIN_FEATURE(pobj)->axes.rect == BT_ON || pSUBWIN_FEATURE(pobj)->axes.rect == BT_BACK_HALF ) ;
2570     case SCI_LABEL:
2571     case SCI_POLYLINE:
2572     case SCI_RECTANGLE:
2573     case SCI_ARC:
2574     case SCI_FIGURE:
2575     case SCI_SURFACE:
2576     case SCI_AXES:
2577     case SCI_LEGEND:
2578     case SCI_SEGS:
2579     case SCI_FEC:
2580     case SCI_GRAYPLOT:
2581     case SCI_AGREG:
2582     case SCI_UIMENU:
2583     default:
2584         printSetGetErrorMessage("box_type");
2585         return 0;
2586         break;
2587     }
2588     return 0;
2589 }
2590
2591 int * sciGetInterpVector(sciPointObj * pobj)
2592 {
2593
2594     if(sciGetEntityType(pobj) != SCI_POLYLINE)
2595         return (int *) NULL;
2596
2597     return pPOLYLINE_FEATURE(pobj)->scvector;
2598 }
2599
2600 BOOL sciGetIsColorInterpolated(sciPointObj * pobj)
2601 {
2602     switch ( sciGetEntityType (pobj) )
2603     {
2604     case SCI_POLYLINE:
2605         return pPOLYLINE_FEATURE(pobj)->isinterpshaded;
2606     default:
2607         printSetGetErrorMessage("interp_vector");
2608         break;
2609     }
2610     return FALSE;
2611 }
2612
2613 BOOL sciGetAutoRotation ( sciPointObj * pObj )
2614 {
2615     switch (sciGetEntityType (pObj))
2616     {
2617     case SCI_LABEL:
2618         return pLABEL_FEATURE(pObj)->auto_rotation ;
2619         break;
2620     case SCI_POLYLINE:
2621     case SCI_RECTANGLE:
2622     case SCI_ARC:
2623     case SCI_TEXT:
2624     case SCI_FIGURE:
2625     case SCI_SUBWIN:
2626     case SCI_SURFACE:
2627     case SCI_AXES:
2628     case SCI_FEC:
2629     case SCI_SEGS:
2630     case SCI_LEGEND:
2631     case SCI_GRAYPLOT:
2632     case SCI_AGREG:
2633     case SCI_UIMENU:
2634     default:
2635         return FALSE;
2636         break;
2637     }
2638     return FALSE;
2639 }
2640
2641 BOOL sciGetAutoPosition ( sciPointObj * pObj )
2642 {
2643     switch (sciGetEntityType (pObj))
2644     {
2645     case SCI_LABEL:
2646         return pLABEL_FEATURE(pObj)->auto_position ;
2647         break;
2648     case SCI_POLYLINE:
2649     case SCI_RECTANGLE:
2650     case SCI_ARC:
2651     case SCI_TEXT:
2652     case SCI_FIGURE:
2653     case SCI_SUBWIN:
2654     case SCI_SURFACE:
2655     case SCI_AXES:
2656     case SCI_FEC:
2657     case SCI_SEGS:
2658     case SCI_LEGEND:
2659     case SCI_GRAYPLOT:
2660     case SCI_AGREG:
2661     case SCI_UIMENU:
2662     default:
2663         return FALSE;
2664         break;
2665     }
2666     return FALSE;
2667 }
2668
2669 /*-----------------------------------------------------------------------------------*/
2670 BOOL sciGetLegendDefined(char * pObjUID)
2671 {
2672     char* xLabelId = NULL;
2673     char* yLabelId = NULL;
2674     char* zLabelId = NULL;
2675
2676     if (pObjUID == NULL)
2677     {
2678         return FALSE;
2679     }
2680
2681     getGraphicObjectProperty(pObjUID, __GO_X_AXIS_LABEL__, jni_string, &xLabelId);
2682     getGraphicObjectProperty(pObjUID, __GO_Y_AXIS_LABEL__, jni_string, &yLabelId);
2683     getGraphicObjectProperty(pObjUID, __GO_Z_AXIS_LABEL__, jni_string, &zLabelId);
2684
2685     /* get the text size of labels */
2686     if (sciisTextEmpty(xLabelId) &&
2687         sciisTextEmpty(yLabelId) &&
2688         sciisTextEmpty(zLabelId))
2689     {
2690         return FALSE;
2691     }
2692     else
2693     {
2694         return TRUE;
2695     }
2696 }
2697 /*-----------------------------------------------------------------------------------*/
2698 BOOL sciGetAutoSize( sciPointObj * pObj )
2699 {
2700     switch (sciGetEntityType (pObj))
2701     {
2702     case SCI_TEXT:
2703         return pTEXT_FEATURE(pObj)->autoSize ;
2704         break;
2705     default:
2706         return FALSE;
2707         break;
2708     }
2709     return FALSE;
2710 }
2711 /*-----------------------------------------------------------------------------------*/
2712 sciTextAlignment sciGetAlignment( sciPointObj * pObj )
2713 {
2714     switch (sciGetEntityType (pObj))
2715     {
2716     case SCI_TEXT:
2717         return pTEXT_FEATURE(pObj)->stringsAlign ;
2718         break;
2719     default:
2720         printSetGetErrorMessage("text_alignment");
2721         return ALIGN_NONE ;
2722     }
2723     return ALIGN_NONE ;
2724 }
2725 /*-----------------------------------------------------------------------------------*/
2726 void sciGetUserSize( sciPointObj * pObj, double * width, double * height )
2727 {
2728     switch( sciGetEntityType( pObj ) )
2729     {
2730     case SCI_TEXT:
2731         *width  = pTEXT_FEATURE(pObj)->userSize[0] ;
2732         *height = pTEXT_FEATURE(pObj)->userSize[1] ;
2733         break ;
2734     default:
2735         printSetGetErrorMessage("text_box");
2736         break ;
2737     }
2738 }
2739 /*-----------------------------------------------------------------------------------*/
2740 /**
2741 * get how is displayed the text around its position.
2742 * If TRUE, the position is the middle of the displayed string.
2743 * If FALSE, it is the lower right corner.
2744 */
2745 BOOL sciGetCenterPos( sciPointObj * pObj )
2746 {
2747     switch( sciGetEntityType( pObj ) )
2748     {
2749     case SCI_TEXT:
2750         return pTEXT_FEATURE(pObj)->centeredPos ;
2751         break ;
2752     default:
2753         printSetGetErrorMessage("text_box_mode");
2754         return FALSE ;
2755     }
2756 }
2757 /*-----------------------------------------------------------------------------------*/
2758 /**
2759 * return wether the current object is displayed in 2d or 3d mode.
2760 */
2761 BOOL sciGetIs3d( sciPointObj * pObj )
2762 {
2763     switch( sciGetEntityType( pObj ) )
2764     {
2765     case SCI_SUBWIN:
2766         return pSUBWIN_FEATURE(pObj)->is3d ;
2767     case SCI_TEXT:
2768         return pTEXT_FEATURE( pObj )->is3d ;
2769     case SCI_LABEL:
2770         return sciGetIs3d( pLABEL_FEATURE( pObj )->text ) ;
2771     default:
2772         printSetGetErrorMessage("view");
2773         return FALSE ;
2774     }
2775     return FALSE ;
2776 }
2777 /*-----------------------------------------------------------------------------------*/
2778 /**
2779 * get the number of children of a graphic object
2780 * @return number of children of object pObj
2781 */
2782 int sciGetNbChildren( sciPointObj * pObj )
2783 {
2784     int nbChildren = 0 ;
2785     sciSons * curSon = sciGetSons( pObj ) ;
2786     while ( curSon != NULL && curSon->pointobj != NULL )
2787     {
2788         nbChildren++ ;
2789         curSon = curSon->pnext ;
2790     }
2791     return nbChildren ;
2792 }
2793 /*-----------------------------------------------------------------------------------*/
2794 /**
2795 * Return if an object directly accessible as a son of an other in Scilab.
2796 * For instance, Label objects are not accessible.
2797 * @return TRUE if the object is accessible, FALSE otherwise.
2798 */
2799 BOOL sciGetIsAccessibleChild( sciPointObj * pObj )
2800 {
2801     return sciGetEntityType( pObj ) != SCI_LABEL
2802         && GetHandleVisibilityOnUimenu( pObj ) ;
2803 }
2804 /*-----------------------------------------------------------------------------------*/
2805 BOOL GetHandleVisibilityOnUimenu( sciPointObj * pobj )
2806 {
2807     if (sciGetEntityType(pobj)!=SCI_UIMENU) { return TRUE ; }
2808
2809     return pUIMENU_FEATURE(pobj)->handle_visible;
2810 }
2811 /*-----------------------------------------------------------------------------------*/
2812 /**
2813 * return the number of object of a certain type which can be found among the descendants
2814 * of an object.
2815 * To get the number of surfaces of a subwindow, it is much faster to use the
2816 * sciGetSubwinNbSurf funtion.
2817 */
2818 int sciGetNbTypedObjects( sciPointObj * pObj, sciEntityType type )
2819 {
2820     int nbFound = 0 ;
2821     sciSons * curSon ;
2822
2823     curSon = sciGetSons( pObj ) ;
2824     while( curSon != NULL )
2825     {
2826         if ( sciGetEntityType( curSon->pointobj ) == type )
2827         {
2828             nbFound++ ;
2829         }
2830         nbFound += sciGetNbTypedObjects( curSon->pointobj, type ) ;
2831         curSon = curSon->pnext ;
2832     }
2833     return nbFound ;
2834 }
2835 /*-----------------------------------------------------------------------------------*/
2836 /**
2837 * return the hidden color of a surface or the inherated attribute of a subwindow.
2838 */
2839 int sciGetHiddenColor( sciPointObj * pObj )
2840 {
2841
2842     int colorIndex;
2843     switch( sciGetEntityType( pObj ) )
2844     {
2845     case SCI_SUBWIN:
2846         colorIndex = pSUBWIN_FEATURE(pObj)->hiddencolor;
2847         break;
2848     case SCI_SURFACE:
2849         colorIndex = pSURFACE_FEATURE(pObj)->hiddencolor;
2850         break;
2851     default:
2852         printSetGetErrorMessage("hidden_color");
2853         return -10 ;
2854     }
2855     return colorIndex ;
2856 }
2857 /*----------------------------------------------------------------------------------*/
2858 /**
2859 * return the color of the back trihedron of an subwin object.
2860 */
2861 int sciGetHiddenAxisColor( sciPointObj * pObj )
2862 {
2863
2864     int colorIndex;
2865     switch( sciGetEntityType( pObj ) )
2866     {
2867     case SCI_SUBWIN:
2868         colorIndex = pSUBWIN_FEATURE(pObj)->axes.hiddenAxisColor + 1 ;
2869         break;
2870     default:
2871         printSetGetErrorMessage("hidden_axis_color");
2872         return -10 ;
2873     }
2874     colorIndex = sciGetGoodIndex(pObj, colorIndex);
2875     return colorIndex ;
2876 }
2877 /*----------------------------------------------------------------------------------*/
2878 /**
2879 * return if the drawlater mode is on for the parent figure.
2880 */
2881 BOOL sciGetIsAutoDrawable( sciPointObj * pobj )
2882 {
2883     return (sciGetImmediateDrawingMode(pobj) && !sciGetPixmapMode(pobj));
2884 }
2885 /*----------------------------------------------------------------------------------*/
2886 BOOL sciGetImmediateDrawingMode(sciPointObj * pobj)
2887 {
2888     return pFIGURE_FEATURE(sciGetParentFigure(pobj))->auto_redraw ;
2889 }
2890 /*----------------------------------------------------------------------------------*/
2891 /**
2892 * To retrieve the type of grid for each dimension
2893 */
2894 void sciGetGridStyle( sciPointObj * pObj, int * xStyle, int * yStyle, int * zStyle )
2895 {
2896     switch ( sciGetEntityType (pObj) )
2897     {
2898     case SCI_SUBWIN:
2899         if (xStyle != NULL) {*xStyle = pSUBWIN_FEATURE(pObj)->grid[0];}
2900         if (yStyle != NULL) {*yStyle = pSUBWIN_FEATURE(pObj)->grid[1];}
2901         if (zStyle != NULL) {*zStyle = pSUBWIN_FEATURE(pObj)->grid[2];}
2902         break ;
2903     default:
2904         printSetGetErrorMessage("grid");
2905         break;
2906     }
2907 }
2908 /*----------------------------------------------------------------------------------*/
2909 /**
2910 * To retrieve the viewport property
2911 * viewport property is only enable when the auto_resize property of the figure is
2912 * disable.
2913 */
2914 void sciGetViewport( sciPointObj * pObj, int viewport[4] )
2915 {
2916     switch ( sciGetEntityType(pObj) )
2917     {
2918     case SCI_FIGURE:
2919         if (isFigureModel(pObj->UID))
2920         {
2921             viewport[0] = pFIGURE_FEATURE(pObj)->pModelData->viewport[0];
2922             viewport[1] = pFIGURE_FEATURE(pObj)->pModelData->viewport[1];
2923             viewport[2] = pFIGURE_FEATURE(pObj)->pModelData->viewport[2];
2924             viewport[3] = pFIGURE_FEATURE(pObj)->pModelData->viewport[3];
2925         }
2926         else
2927         {
2928             sciGetJavaViewport(pObj, viewport);
2929         }
2930         break;
2931     default:
2932         printSetGetErrorMessage("viewport");
2933         break;
2934     }
2935 }
2936 /*----------------------------------------------------------------------------------*/
2937 void sciGetInfoMessage( sciPointObj * pObj, char * infoMessage )
2938 {
2939     switch ( sciGetEntityType(pObj) )
2940     {
2941     case SCI_FIGURE:
2942         if (isFigureModel(pObj->UID))
2943         {
2944             strcpy(infoMessage, pFIGURE_FEATURE(pObj)->pModelData->infoMessage);
2945         }
2946         else
2947         {
2948             sciGetJavaInfoMessage(pObj, infoMessage);
2949         }
2950         break;
2951     default:
2952         printSetGetErrorMessage("info_message");
2953         break;
2954     }
2955 }
2956 /*----------------------------------------------------------------------------------*/
2957 int sciGetInfoMessageLength( sciPointObj * pObj )
2958 {
2959     switch ( sciGetEntityType(pObj) )
2960     {
2961     case SCI_FIGURE:
2962         if (isFigureModel(pObj->UID))
2963         {
2964             return (int) strlen( pFIGURE_FEATURE(pObj)->pModelData->infoMessage ) ;
2965         }
2966         else
2967         {
2968             return sciGetJavaInfoMessageLength(pObj);
2969         }
2970     default:
2971         printSetGetErrorMessage("info_message");
2972         return -1 ;
2973     }
2974     return -1 ;
2975
2976 }
2977 /*----------------------------------------------------------------------------------*/
2978 void sciGetScreenPosition( sciPointObj * pObj, int * posX, int * posY )
2979 {
2980     switch ( sciGetEntityType(pObj) )
2981     {
2982     case SCI_FIGURE:
2983         if ( pObj == getFigureModel() )
2984         {
2985             *posX = pFIGURE_FEATURE(pObj)->pModelData->windowPosition[0] ;
2986             *posY = pFIGURE_FEATURE(pObj)->pModelData->windowPosition[1] ;
2987         }
2988         else
2989         {
2990             int pos[2];
2991             sciGetJavaWindowPosition(pObj, pos) ;
2992             *posX = pos[0] ;
2993             *posY = pos[1] ;
2994         }
2995         break ;
2996     default:
2997         printSetGetErrorMessage("figure_position");
2998         *posX = -1 ;
2999         *posY = -1 ;
3000     }
3001 }
3002 /*----------------------------------------------------------------------------------*/
3003 BOOL sciGetIsEventHandlerEnable( sciPointObj * pObj )
3004 {
3005     switch ( sciGetEntityType(pObj) )
3006     {
3007     case SCI_FIGURE:
3008         {
3009             return pFIGURE_FEATURE( pObj )->isEventHandlerEnable ;
3010         }
3011         break ;
3012     default:
3013         printSetGetErrorMessage("event_handler");
3014         return FALSE ;
3015     }
3016     return FALSE ;
3017 }
3018 /*----------------------------------------------------------------------------------*/
3019 char * sciGetEventHandler( sciPointObj * pObj )
3020 {
3021     switch ( sciGetEntityType(pObj) )
3022     {
3023     case SCI_FIGURE:
3024         {
3025             return pFIGURE_FEATURE(pObj)->eventHandler ;
3026         }
3027         break ;
3028     default:
3029         printSetGetErrorMessage("event_handler");
3030         return NULL ;
3031     }
3032     return NULL ;
3033 }
3034 /*----------------------------------------------------------------------------------*/
3035 double * sciGetAxesBounds( sciPointObj * pObj )
3036 {
3037     switch( sciGetEntityType(pObj) )
3038     {
3039     case SCI_SUBWIN:
3040         return pSUBWIN_FEATURE(pObj)->WRect;
3041     default:
3042         printSetGetErrorMessage("axes_bounds");
3043         return NULL ;
3044     }
3045 }
3046 /*----------------------------------------------------------------------------------*/
3047 double * sciGetMargins( sciPointObj * pObj )
3048 {
3049     switch( sciGetEntityType(pObj) )
3050     {
3051     case SCI_SUBWIN:
3052         return pSUBWIN_FEATURE(pObj)->ARect;
3053     default:
3054         printSetGetErrorMessage("margins");
3055         return NULL ;
3056     }
3057 }
3058 /*----------------------------------------------------------------------------------*/
3059 /**
3060 * To get the computed data bounds of a subwin.
3061 * * @param bounds [Xmin,Xmax,Ymin,Ymax,Zmin,Zmax] vector.
3062 */
3063 void sciGetRealDataBounds( 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)->FRect[i] ;
3072         }
3073         return ;
3074     default:
3075         printSetGetErrorMessage("data_bounds");
3076         for ( i = 0 ; i < 6 ; i++ )
3077         {
3078             bounds[i] = 0.0 ;
3079         }
3080     }
3081     return ;
3082 }
3083 /*----------------------------------------------------------------------------------*/
3084 /**
3085 * Get the bounds we need to use for a subwin (between user defined one and zoomed ones).
3086 */
3087 void sciGetDisplayedDataBounds(sciPointObj * pObj, double bounds[6])
3088 {
3089     if(sciGetZooming(pObj))
3090     {
3091         sciGetZoomBox(pObj, bounds);
3092     }
3093     else
3094     {
3095         sciGetDataBounds(pObj, bounds);
3096     }
3097 }
3098 /*----------------------------------------------------------------------------------*/
3099 /**
3100 * Get data-bounds defined by the user and not modified for pretty print by scilab.
3101 * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
3102 */
3103 void sciGetDataBounds( sciPointObj * pObj, double bounds[6] )
3104 {
3105     int i;
3106     switch( sciGetEntityType(pObj) )
3107     {
3108     case SCI_SUBWIN:
3109         for ( i = 0 ; i < 6 ; i++ )
3110         {
3111             bounds[i] = pSUBWIN_FEATURE(pObj)->SRect[i] ;
3112         }
3113         return ;
3114     case SCI_SURFACE:
3115         for ( i = 0 ; i < 6 ; i++ )
3116         {
3117             bounds[i] = pSURFACE_FEATURE(pObj)->ebox[i] ;
3118         }
3119         return ;
3120     default:
3121         printSetGetErrorMessage("data_bounds");
3122         for ( i = 0 ; i < 6 ; i++ )
3123         {
3124             bounds[i] = 0.0 ;
3125         }
3126     }
3127     return ;
3128 }
3129 /*----------------------------------------------------------------------------------*/
3130 /**
3131 * Get the viewing angles of a subwindow in degrees.
3132 */
3133 void sciGetViewingAngles( sciPointObj * pObj, double * alpha, double * theta)
3134 {
3135     switch( sciGetEntityType(pObj) )
3136     {
3137     case SCI_SUBWIN:
3138         *alpha = pSUBWIN_FEATURE(pObj)->alpha;
3139         *theta = pSUBWIN_FEATURE(pObj)->theta;
3140         break;
3141     default:
3142         printSetGetErrorMessage("rotation_angles");
3143         *alpha = 0.0;
3144         *theta = 0.0;
3145         break;
3146     }
3147 }
3148 /*----------------------------------------------------------------------------------*/
3149 /**
3150 * Copy the logflags of a subwin to an array of size 3.
3151 */
3152 void sciGetLogFlags(char * pObjUID, char flags[3])
3153 {
3154     char* logflagPropertyNames[3] = {__GO_X_AXIS_LOG_FLAG__, __GO_Y_AXIS_LOG_FLAG__, __GO_Z_AXIS_LOG_FLAG__};
3155     int i;
3156     int iLogFlag = 0;
3157     int* piLogFlag = &iLogFlag;
3158
3159     for (i = 0; i < 3; i++)
3160     {
3161         getGraphicObjectProperty(pObjUID, logflagPropertyNames[i], jni_bool, &piLogFlag);
3162
3163         if (piLogFlag == NULL)
3164         {
3165             printSetGetErrorMessage("log_flags");
3166             return;
3167         }
3168
3169         if (iLogFlag)
3170         {
3171             flags[i] = 'l';
3172         }
3173         else
3174         {
3175             flags[i] = 'n';
3176         }
3177     }
3178 }
3179 /*----------------------------------------------------------------------------------*/
3180 /**
3181 * To know if the pixmap mode a figure is on or off.
3182 */
3183 BOOL sciGetPixmapMode(sciPointObj * pObj)
3184 {
3185     switch(sciGetEntityType(pObj))
3186     {
3187     case SCI_FIGURE:
3188         return pFIGURE_FEATURE(pObj)->pixmapMode;
3189         break;
3190     default:
3191         printSetGetErrorMessage("pixmap");
3192         break;
3193     }
3194     return FALSE;
3195 }
3196 /*----------------------------------------------------------------------------------*/
3197 /**
3198 * @return number of vertices of a pointObj
3199 */
3200 int sciGetNbPoints(sciPointObj * pObj)
3201 {
3202     switch(sciGetEntityType(pObj))
3203     {
3204     case SCI_POLYLINE:
3205         return pPOLYLINE_FEATURE(pObj)->n1;
3206     default:
3207         printSetGetErrorMessage("points");
3208         break;
3209     }
3210     return -1;
3211 }
3212 /*----------------------------------------------------------------------------------*/
3213 int sciGetPolylineStyle(sciPointObj * pObj)
3214 {
3215     switch(sciGetEntityType(pObj))
3216     {
3217     case SCI_POLYLINE:
3218         return pPOLYLINE_FEATURE(pObj)->plot;
3219     default:
3220         printSetGetErrorMessage("polyline_style");
3221         break;
3222     }
3223     return -1;
3224 }
3225 /*----------------------------------------------------------------------------------*/
3226 BOOL sciGetIsClosed(sciPointObj * pObj)
3227 {
3228     switch(sciGetEntityType(pObj))
3229     {
3230     case SCI_POLYLINE:
3231         return pPOLYLINE_FEATURE(pObj)->closed;
3232     default:
3233         printSetGetErrorMessage("closed");
3234         break;
3235     }
3236     return FALSE;
3237 }
3238 /*----------------------------------------------------------------------------------*/
3239 double sciGetArrowSize(sciPointObj * pObj)
3240 {
3241     switch(sciGetEntityType(pObj))
3242     {
3243     case SCI_POLYLINE:
3244         return pPOLYLINE_FEATURE(pObj)->arsize_factor;
3245     case SCI_SEGS:
3246         return pSEGS_FEATURE(pObj)->arrowsize;
3247     default:
3248         printSetGetErrorMessage("arrow_size");
3249         break;
3250     }
3251     return -1;
3252 }
3253 /*----------------------------------------------------------------------------------*/
3254 void sciGetTextPos(sciPointObj * pObj, double position[3])
3255 {
3256     switch(sciGetEntityType(pObj))
3257     {
3258     case SCI_TEXT:
3259         position[0] = pTEXT_FEATURE(pObj)->x;
3260         position[1] = pTEXT_FEATURE(pObj)->y;
3261         position[2] = pTEXT_FEATURE(pObj)->z;
3262         break;
3263     case SCI_LABEL:
3264         sciGetTextPos(pLABEL_FEATURE(pObj)->text, position);
3265         break;
3266     default:
3267         printSetGetErrorMessage("data");
3268         position[0] = 0.0;
3269         position[1] = 0.0;
3270         position[2] = 0.0;
3271         break;
3272     }
3273 }
3274 /*----------------------------------------------------------------------------------*/
3275 /**
3276 * Convert user coordinates to pixel ones (relative to the viewing canvas).
3277 * @param pObj subwindow handle
3278 * @param userCoord user coordinates
3279 * @param pixCoord result in pixels.
3280 */
3281 void sciGetPixelCoordinate(sciPointObj * pObj, const double userCoord[3], int pixCoord[2])
3282 {
3283     switch(sciGetEntityType(pObj))
3284     {
3285     case SCI_SUBWIN:
3286         sciGetJavaPixelCoordinates(pObj, userCoord, pixCoord);
3287         break;
3288     default:
3289         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3290         pixCoord[0] = -1;
3291         pixCoord[1] = -1;
3292         break;
3293     }
3294 }
3295 /*----------------------------------------------------------------------------------*/
3296 /**
3297 * Convert user coordinates to user cooordinates (2D).
3298 * @param pObj subwindow handle
3299 * @param userCoord3D user coordinates
3300 * @param userCoords2D result in user coordinates in the default 2D plane.
3301 */
3302 void sciGet2dViewCoordinate(sciPointObj * pObj, const double userCoords3D[3], double userCoords2D[2])
3303 {
3304     switch(sciGetEntityType(pObj))
3305     {
3306     case SCI_SUBWIN:
3307         sciGetJava2dViewCoordinates(pObj, userCoords3D, userCoords2D);
3308         break;
3309     default:
3310         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3311         userCoords2D[0] = 0.0;
3312         userCoords2D[1] = 0.0;
3313         break;
3314     }
3315 }
3316 /*----------------------------------------------------------------------------------*/
3317 /**
3318 * Convert pixel coordinates to 2D view coordinate
3319 * @param pObj subwindow handle
3320 * @param userCoord pixel coordinates
3321 * @param userCoords2D user coordinates in default 2D plane
3322 */
3323 void sciGet2dViewCoordFromPixel(sciPointObj * pObj, const int pixelCoords[2], double userCoords2D[2])
3324 {
3325     switch(sciGetEntityType(pObj))
3326     {
3327     case SCI_SUBWIN:
3328         sciGetJava2dViewCoordFromPixel(pObj, pixelCoords, userCoords2D);
3329         break;
3330     default:
3331         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3332         userCoords2D[0] = 0.0;
3333         userCoords2D[1] = 0.0;
3334         break;
3335     }
3336 }
3337 /*----------------------------------------------------------------------------------*/
3338 /**
3339 * Convert 2d view coordinates to pixel coordinates
3340 * @param pObj subwindow handle
3341 * @param userCoords2D coordinates in th default 2D plane
3342 * @param pixelsCoords pixel coordinates
3343 */
3344 void sciGet2dViewPixelCoordinates(sciPointObj * pObj, const double userCoords2D[2], int pixelCoords[2])
3345 {
3346     switch(sciGetEntityType(pObj))
3347     {
3348     case SCI_SUBWIN:
3349         {
3350             /* create a 3d user coord */
3351             double userCoord3D[3] = {userCoords2D[0], userCoords2D[1], 0.0};
3352             sciGetJava2dViewPixelCoordinates(pObj, userCoord3D, pixelCoords);
3353         }
3354         break;
3355     default:
3356         Scierror(999, _("Coordinates modifications are only applicable on axes objects.\n"));
3357         pixelCoords[0] = -1;
3358         pixelCoords[1] = -1;
3359         break;
3360     }
3361 }
3362 /*----------------------------------------------------------------------------------*/
3363 /**
3364 * @return TRUE if pObj is a subwin with isoview mode on.
3365 */
3366 BOOL sciGetIsIsoView(sciPointObj * pObj)
3367 {
3368     switch(sciGetEntityType(pObj))
3369     {
3370     case SCI_SUBWIN:
3371         return pSUBWIN_FEATURE(pObj)->isoview;
3372     default:
3373         return FALSE;
3374         break;
3375     }
3376 }
3377 /*----------------------------------------------------------------------------------*/
3378 /**
3379 * @return TRUE if pObj is a subwindow with cube scaling mode on.
3380 */
3381 BOOL sciGetIsCubeScaled(sciPointObj * pObj)
3382 {
3383     switch(sciGetEntityType(pObj))
3384     {
3385     case SCI_SUBWIN:
3386         return pSUBWIN_FEATURE(pObj)->cube_scaling;
3387     default:
3388         return FALSE;
3389         break;
3390     }
3391 }
3392 /*----------------------------------------------------------------------------------*/
3393 /**
3394 * Get axes reverse property for each axis of a subwin object
3395 */
3396 void sciGetAxesReverse(sciPointObj * pObj, BOOL axesReverse[3])
3397 {
3398     switch(sciGetEntityType(pObj))
3399     {
3400     case SCI_SUBWIN:
3401         axesReverse[0] = pSUBWIN_FEATURE(pObj)->axes.reverse[0];
3402         axesReverse[1] = pSUBWIN_FEATURE(pObj)->axes.reverse[1];
3403         axesReverse[2] = pSUBWIN_FEATURE(pObj)->axes.reverse[2];
3404         break;
3405     default:
3406         printSetGetErrorMessage("axes_reverse");
3407         break;
3408     }
3409 }
3410 /*----------------------------------------------------------------------------------*/
3411 /**
3412 * @return TRUE if subwindow pObj tight_limit mode is on.
3413 */
3414 BOOL sciGetTightLimitsOn(sciPointObj * pObj)
3415 {
3416     switch(sciGetEntityType(pObj))
3417     {
3418     case SCI_SUBWIN:
3419         return pSUBWIN_FEATURE(pObj)->tight_limits;
3420     default:
3421         return FALSE;
3422         break;
3423     }
3424 }
3425 /*----------------------------------------------------------------------------------*/
3426 /**
3427 * Get auto_ticks property for each axis
3428 */
3429 void sciGetAutoTicks(sciPointObj * pObj, BOOL autoTicks[3])
3430 {
3431     switch(sciGetEntityType(pObj))
3432     {
3433     case SCI_SUBWIN:
3434         autoTicks[0] = pSUBWIN_FEATURE(pObj)->axes.auto_ticks[0];
3435         autoTicks[1] = pSUBWIN_FEATURE(pObj)->axes.auto_ticks[1];
3436         autoTicks[2] = pSUBWIN_FEATURE(pObj)->axes.auto_ticks[2];
3437         break;
3438     default:
3439         autoTicks[0] = FALSE;
3440         autoTicks[1] = FALSE;
3441         autoTicks[2] = FALSE;
3442         printSetGetErrorMessage("auto_ticks");
3443         break;
3444     }
3445 }
3446 /*----------------------------------------------------------------------------------*/
3447 /**
3448 * Get auto_ticks property for each axis
3449 */
3450 BOOL sciGetAutoSubticks(sciPointObj * pObj)
3451 {
3452     switch(sciGetEntityType(pObj))
3453     {
3454     case SCI_SUBWIN:
3455         return !(pSUBWIN_FEATURE(pObj)->flagNax);
3456         break;
3457     default:
3458         return FALSE;
3459         printSetGetErrorMessage("auto_subticks");
3460         break;
3461     }
3462 }
3463 /*----------------------------------------------------------------------------------*/
3464 /**
3465 * Get nbsubtics for each axis
3466 */
3467 void sciGetNbSubTics(sciPointObj * pObj, int nbsubtics[3])
3468 {
3469     switch(sciGetEntityType(pObj))
3470     {
3471     case SCI_SUBWIN:
3472         nbsubtics[0] = pSUBWIN_FEATURE(pObj)->axes.nbsubtics[0];
3473         nbsubtics[1] = pSUBWIN_FEATURE(pObj)->axes.nbsubtics[1];
3474         nbsubtics[2] = pSUBWIN_FEATURE(pObj)->axes.nbsubtics[2];
3475         break;
3476     default:
3477         nbsubtics[0] = 0;
3478         nbsubtics[1] = 0;
3479         nbsubtics[2] = 0;
3480         printSetGetErrorMessage("nbsubtics");
3481         break;
3482     }
3483 }
3484 /*----------------------------------------------------------------------------------*/
3485 /**
3486 * Get the axes visible property for each axis.
3487 */
3488 void sciGetAxesVisible(sciPointObj * pObj, BOOL axesVisible[3])
3489 {
3490     switch(sciGetEntityType(pObj))
3491     {
3492     case SCI_SUBWIN:
3493         axesVisible[0] = pSUBWIN_FEATURE(pObj)->axes.axes_visible[0];
3494         axesVisible[1] = pSUBWIN_FEATURE(pObj)->axes.axes_visible[1];
3495         axesVisible[2] = pSUBWIN_FEATURE(pObj)->axes.axes_visible[2];
3496         break;
3497     default:
3498         axesVisible[0] = FALSE;
3499         axesVisible[1] = FALSE;
3500         axesVisible[2] = FALSE;
3501         printSetGetErrorMessage("axes_visible");
3502         break;
3503     }
3504 }
3505 /*----------------------------------------------------------------------------------*/
3506 /**
3507 * Get the current zoom box of a subwin object
3508 * @param[out] zoomBox output parameter with thte zoom box
3509 */
3510 void sciGetZoomBox(sciPointObj * pObj, double zoomBox[6])
3511 {
3512     switch(sciGetEntityType(pObj))
3513     {
3514     case SCI_SUBWIN:
3515         zoomBox[0] = pSUBWIN_FEATURE(pObj)->ZRect[0] ;
3516         zoomBox[1] = pSUBWIN_FEATURE(pObj)->ZRect[1] ;
3517         zoomBox[2] = pSUBWIN_FEATURE(pObj)->ZRect[2] ;
3518         zoomBox[3] = pSUBWIN_FEATURE(pObj)->ZRect[3] ;
3519         zoomBox[4] = pSUBWIN_FEATURE(pObj)->ZRect[4] ;
3520         zoomBox[5] = pSUBWIN_FEATURE(pObj)->ZRect[5] ;
3521         break;
3522     default:
3523         printSetGetErrorMessage("zoom_box");
3524         break;
3525     }
3526 }
3527 /*----------------------------------------------------------------------------------*/
3528 /**
3529 * Get the 4 corners of the bounding box of a text object in 3D
3530 */
3531 void sciGetTextBoundingBox(sciPointObj * pObj, double corner1[3], double corner2[3],
3532                            double corner3[3], double corner4[3])
3533 {
3534     switch (sciGetEntityType(pObj))
3535     {
3536     case SCI_TEXT:
3537         {
3538             int i;
3539             for (i = 0; i < 3; i++)
3540             {
3541                 // should be up to date
3542                 corner1[i] = pTEXT_FEATURE(pObj)->corners[0][i];
3543                 corner2[i] = pTEXT_FEATURE(pObj)->corners[1][i];
3544                 corner3[i] = pTEXT_FEATURE(pObj)->corners[2][i];
3545                 corner4[i] = pTEXT_FEATURE(pObj)->corners[3][i];
3546             }
3547         }
3548         break;
3549     case SCI_LABEL:
3550         sciGetTextBoundingBox(pLABEL_FEATURE(pObj)->text, corner1, corner2, corner3, corner4);
3551         break;
3552
3553     default:
3554         printSetGetErrorMessage("bounding box");
3555         break;
3556     }
3557 }
3558 /*----------------------------------------------------------------------------------*/
3559 /**
3560 * Get the 4 corners of the bounding box of a text object in pixels
3561 */
3562 void sciGetPixelBoundingBox(sciPointObj * pObj, int corner1[2], int corner2[2],
3563                             int corner3[2], int corner4[2])
3564 {
3565     sciGetJavaPixelBoundingBox(pObj, corner1, corner2, corner3, corner4);
3566 }
3567 /*----------------------------------------------------------------------------------*/
3568 /**
3569 * Get the 4 corners of the boundng box of a text object in 2D view user coordinates.
3570 */
3571 void sciGet2dViewBoundingBox(sciPointObj * pObj, double corner1[2], double corner2[2],
3572                              double corner3[2], double corner4[2])
3573 {
3574     sciPointObj * parentSubwin = sciGetParentSubwin(pObj);
3575     double corners3d[4][3];
3576
3577     /* get bounding box */
3578     sciGetTextBoundingBox(pObj, corners3d[0], corners3d[1], corners3d[2], corners3d[3]);
3579
3580     /* convert it to 2d view coordinates */
3581     sciGetJava2dViewCoordinates(parentSubwin, corners3d[0], corner1);
3582     sciGetJava2dViewCoordinates(parentSubwin, corners3d[1], corner2);
3583     sciGetJava2dViewCoordinates(parentSubwin, corners3d[2], corner3);
3584     sciGetJava2dViewCoordinates(parentSubwin, corners3d[3], corner4);
3585
3586 }
3587 /*----------------------------------------------------------------------------------*/
3588 /**
3589 * Get the viewing area of a subwindown acoordinf to its axes scale and margins
3590 * result is in pixels
3591 */
3592 void sciGetViewingArea(sciPointObj * pObj, int * xPos, int * yPos, int * width, int * height)
3593 {
3594     switch (sciGetEntityType(pObj))
3595     {
3596     case SCI_SUBWIN:
3597         sciGetJavaViewingArea(pObj, xPos, yPos, width, height);
3598         break;
3599     default:
3600         *xPos = -1;
3601         *yPos = -1;
3602         *width = -1;
3603         *height = -1;
3604         Scierror(999, _("Only axes handles have a viewing area."));
3605         break;
3606     }
3607 }
3608 /*----------------------------------------------------------------------------------*/
3609 /**
3610 * Get the axis aligned bounding box a graphic object
3611 * @param bounds [xmin, xmax, ymin, ymax, zmin, zmax] bounds.
3612 */
3613 void sciGetAABoundingBox(sciPointObj * pObj, double bounds[6])
3614 {
3615     switch (sciGetEntityType(pObj))
3616     {
3617     case SCI_SUBWIN:
3618         sciGetDataBounds(pObj, bounds);
3619         break;
3620     case SCI_SEGS:
3621         sciGetJavaSegsBoundingBox(pObj, bounds);
3622         break;
3623     case SCI_TEXT:
3624         {
3625             double corners[4][3];
3626             sciGetTextBoundingBox(pObj, corners[0], corners[1], corners[2], corners[3]);
3627             bounds[0] = Min(corners[0][0],Min(corners[1][0],Min(corners[2][0],corners[3][0])));
3628             bounds[1] = Max(corners[0][0],Max(corners[1][0],Max(corners[2][0],corners[3][0])));
3629             bounds[2] = Min(corners[0][1],Min(corners[1][1],Min(corners[2][1],corners[3][1])));
3630             bounds[3] = Max(corners[0][1],Max(corners[1][1],Max(corners[2][1],corners[3][1])));
3631             bounds[4] = Min(corners[0][2],Min(corners[1][2],Min(corners[2][2],corners[3][2])));
3632             bounds[5] = Max(corners[0][2],Max(corners[1][2],Max(corners[2][2],corners[3][2])));
3633         }
3634         break;
3635     case SCI_LABEL:
3636         sciGetAABoundingBox(pLABEL_FEATURE(pObj)->text, bounds);
3637         break;
3638     default:
3639         Scierror(999, _("Unable to compute data bounds for this kind of object."));
3640         break;
3641     }
3642 }
3643 /*----------------------------------------------------------------------------------*/
3644 /**
3645 * Get the x_position value
3646 * @param bounds [xmin, xmax, ymin, ymax, zmin, zmax] bounds.
3647 */
3648 char sciGetxLocation(sciPointObj * pObj)
3649 {
3650     switch (sciGetEntityType(pObj))
3651     {
3652     case SCI_SUBWIN:
3653         return pSUBWIN_FEATURE(pObj)->axes.xdir;
3654         break;
3655     default:
3656         Scierror(999, _("Unable to compute x_location for this kind of object."));
3657         break;
3658     }
3659     return NULL;
3660 }
3661 /*----------------------------------------------------------------------------------*/
3662 char sciGetyLocation(sciPointObj * pObj)
3663 {
3664     switch (sciGetEntityType(pObj))
3665     {
3666     case SCI_SUBWIN:
3667         return pSUBWIN_FEATURE(pObj)->axes.ydir;
3668         break;
3669     default:
3670         Scierror(999, _("Unable to compute y_location for this kind of object."));
3671         break;
3672     }
3673     return NULL;
3674 }
3675 /*----------------------------------------------------------------------------------*/
3676 /**
3677 * Check wether an object is using nurbs for display or not
3678 */
3679 BOOL sciGetUseNurbs(sciPointObj * pObj)
3680 {
3681     switch (sciGetEntityType(pObj))
3682     {
3683     case SCI_SUBWIN:
3684         return pSUBWIN_FEATURE(pObj)->useNurbsForArcs;
3685     case SCI_ARC:
3686         return pARC_FEATURE(pObj)->useNurbs;
3687     default:
3688         printSetGetErrorMessage("drawing_method");
3689         return FALSE;
3690     }
3691 }
3692 /*----------------------------------------------------------------------------------*/
3693 /**
3694 * Check wether an object is using fractional metrics for text display
3695 */
3696 BOOL sciGetIsUsingFractionalMetrics(sciPointObj * pObj)
3697 {
3698     sciFont * fontContext = sciGetFontContext(pObj);
3699     if (fontContext != NULL) {
3700         return fontContext->useFractionalMetrics;
3701     }
3702     printSetGetErrorMessage("fractional_font");
3703     return FALSE;
3704 }
3705 /*----------------------------------------------------------------------------------*/
3706 /**
3707 * Get number of subticks on the x,y, and z axes.
3708 * This property is determined by the renderer module.
3709 */
3710 void sciGetNbSubticks(sciPointObj * pSubwin, double nbsubtics[3])
3711 {
3712     sciGetJavaNbSubticks(pSubwin, nbsubtics);
3713 }
3714 /*----------------------------------------------------------------------------------*/
3715 /**
3716 * Get number of ticks along X axis of a subwindow.
3717 */
3718 int sciGetNbXTicks(sciPointObj * pSubwin)
3719 {
3720     return sciGetJavaNbXTicks(pSubwin);
3721 }
3722 /*----------------------------------------------------------------------------------*/
3723 /**
3724 * Get the labels and positions of ticks along X axis.
3725 * String composing ticksLabels are allocated with MALLOC.
3726 */
3727 void sciGetXTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
3728 {
3729     sciGetJavaXTicksPos(pSubwin, ticksPos, ticksLabels);
3730 }
3731 /*----------------------------------------------------------------------------------*/
3732 /**
3733 * Get number of ticks along Y axis of a subwindow.
3734 */
3735 int sciGetNbYTicks(sciPointObj * pSubwin)
3736 {
3737     return sciGetJavaNbYTicks(pSubwin);
3738 }
3739 /*----------------------------------------------------------------------------------*/
3740 /**
3741 * Get the labels and positions of ticks along Y axis.
3742 * String composing ticksLabels are allocated with C++ new.
3743 */
3744 void sciGetYTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
3745 {
3746     sciGetJavaYTicksPos(pSubwin, ticksPos, ticksLabels);
3747 }
3748 /*----------------------------------------------------------------------------------*/
3749 /**
3750 * Get number of ticks along Z axis of a subwindow.
3751 */
3752 int sciGetNbZTicks(sciPointObj * pSubwin)
3753 {
3754     return sciGetJavaNbZTicks(pSubwin);
3755 }
3756 /*----------------------------------------------------------------------------------*/
3757 /**
3758 * Get the labels and positions of ticks along Z axis.
3759 * String composing ticksLabels are allocated with C++ new.
3760 */
3761 void sciGetZTicksPos(sciPointObj * pSubwin, double ticksPos[], char ** ticksLabels)
3762 {
3763     sciGetJavaZTicksPos(pSubwin, ticksPos, ticksLabels);
3764 }
3765 /*----------------------------------------------------------------------------------*/
3766 /**
3767 * Get the labels and positions of ticks along Z axis.
3768 * String composing ticksLabels are allocated with C++ new.
3769 */
3770 BOOL sciGetIsAbleToCreateWindow(void)
3771 {
3772     return sciGetJavaIsAbleToCreateWindow();
3773 }
3774 /*----------------------------------------------------------------------------------*/
3775 /**
3776 * @return index of the subwin between all the subwins lying below its parent figure
3777 */
3778 int sciGetSubwinIndex(sciPointObj * pSubwin)
3779 {
3780     sciPointObj * parentFigure = sciGetParentFigure(pSubwin);
3781     int subwinIndex = 0;
3782     sciSons * pSons = sciGetSons(parentFigure);
3783
3784     while (pSons->pointobj != pSubwin)
3785     {
3786         if (sciGetEntityType(pSons->pointobj) == SCI_SUBWIN)
3787         {
3788             // subwin found
3789             subwinIndex++;
3790         }
3791         pSons = pSons->pnext;
3792     }
3793     return subwinIndex;
3794 }
3795 /*----------------------------------------------------------------------------------*/
3796 /**
3797 * @return TRUE if the object is automatically redraw and does not
3798 *         need to be explicitely drawn (using sciDrawObj).
3799 */
3800 BOOL sciIsAutomaticallyRedrawn(sciPointObj * pObj)
3801 {
3802     sciEntityType entityType = sciGetEntityType(pObj);
3803     return (entityType == SCI_UICONTROL)
3804         || (entityType == SCI_UIMENU)
3805         || (entityType == SCI_UICONTEXTMENU)
3806         || (entityType == SCI_WAITBAR)
3807         || (entityType == SCI_PROGRESSIONBAR);
3808 }
3809 /*----------------------------------------------------------------------------------*/
3810 /**
3811 * Get the subset of colormap bounds used by a particular object (colminmax).
3812 */
3813 void sciGetColorRange(sciPointObj * pObj, int subset[2])
3814 {
3815     switch (sciGetEntityType(pObj))
3816     {
3817     case SCI_FEC:
3818         subset[0] = pFEC_FEATURE(pObj)->colminmax[0];
3819         subset[1] = pFEC_FEATURE(pObj)->colminmax[1];
3820         break;
3821     default:
3822         printSetGetErrorMessage("color_range");
3823         subset[0] = 0;
3824         subset[1] = 0;
3825         break;
3826     }
3827 }
3828 /*----------------------------------------------------------------------------------*/
3829 /**
3830 * Get the color to use for an objects when it uses index outside of the colormap (colout).
3831 */
3832 void sciGetOutsideColor(sciPointObj * pObj, int colors[2])
3833 {
3834     switch (sciGetEntityType(pObj))
3835     {
3836     case SCI_FEC:
3837         colors[0] = pFEC_FEATURE(pObj)->colout[0];
3838         colors[1] = pFEC_FEATURE(pObj)->colout[1];
3839         break;
3840     default:
3841         printSetGetErrorMessage("outside_color");
3842         colors[0] = 0;
3843         colors[1] = 0;
3844         break;
3845     }
3846 }
3847 /*----------------------------------------------------------------------------------*/
3848 /**
3849 * Get the Z range used by a fec object (zminmax).
3850 */
3851 void sciGetZBounds(sciPointObj * pObj, double bounds[2])
3852 {
3853     switch (sciGetEntityType(pObj))
3854     {
3855     case SCI_FEC:
3856         bounds[0] = pFEC_FEATURE(pObj)->zminmax[0];
3857         bounds[1] = pFEC_FEATURE(pObj)->zminmax[1];
3858         break;
3859     default:
3860         printSetGetErrorMessage("z_bounds");
3861         bounds[0] = 0;
3862         bounds[1] = 0;
3863         break;
3864     }
3865 }
3866 /*----------------------------------------------------------------------------------*/
3867 /**
3868 * Get whether the grid is drawn in background or foreground.
3869 */
3870 BOOL sciGetGridFront(sciPointObj * pObj)
3871 {
3872     switch (sciGetEntityType(pObj))
3873     {
3874     case SCI_SUBWIN:
3875         return pSUBWIN_FEATURE(pObj)->gridFront;
3876     default:
3877         printSetGetErrorMessage("grid_position");
3878         return FALSE;
3879     }
3880 }
3881 /*----------------------------------------------------------------------------------*/
3882 /**
3883 * @return the number of pass used for antialiasing or 0 if antialiasing is disable.
3884 */
3885 int sciGetAntialiasingQuality(sciPointObj * pObj)
3886 {
3887     switch (sciGetEntityType(pObj))
3888     {
3889     case SCI_FIGURE:
3890         if (isFigureModel(pObj->UID))
3891         {
3892             return pFIGURE_FEATURE(pObj)->pModelData->antialiasingQuality;
3893         }
3894         else
3895         {
3896             return sciGetJavaAntialiasingQuality(pObj);
3897         }
3898     default:
3899         printSetGetErrorMessage("anti_aliasing");
3900         return FALSE;
3901     }
3902 }
3903 /*----------------------------------------------------------------------------------*/
3904 /**
3905 * Get the position of a legend object relative to its parent subwin
3906 */
3907 sciLegendPlace sciGetLegendLocation(sciPointObj * pObj)
3908 {
3909     switch (sciGetEntityType(pObj))
3910     {
3911     case SCI_LEGEND:
3912         return pLEGEND_FEATURE(pObj)->place;
3913     default:
3914         printSetGetErrorMessage("legend_location");
3915         return SCI_LEGEND_POSITION_UNSPECIFIED;
3916     }
3917 }
3918 /*----------------------------------------------------------------------------------*/
3919 /**
3920 * Print the message "This object has no xxx property." in Scilab.
3921 */
3922 void printSetGetErrorMessage(const char * propertyName)
3923 {
3924     Scierror(999, _("This object has no %s property.\n"), propertyName );
3925 }
3926 /*----------------------------------------------------------------------------------*/
3927