0b7280bad5ccdf0a4fca9302b909784d8287f077
[scilab.git] / scilab / modules / graphics / src / c / BuildObjects.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2001-2002 - INRIA - Mathieu Philippe
4  * Copyright (C) 2002-2004 - INRIA - Djalel Abdemouche
5  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
6  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
7  * Copyright (C) 2007 - INRIA - Vincent Couvert
8  * Copyright (C) 2010 - DIGITEO - Bruno JOFRET
9  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
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 BUILD new objects :
24  - allocating memory
25  - setting default value
26  - binding the newly created object tyo the entire existing hierarchy
27  --------------------------------------------------------------------------*/
28 #include <string.h>
29 #include <stdio.h>
30
31 #include "BuildObjects.h"
32 #include "GetProperty.h"
33 #include "InitObjects.h"
34 #include "DestroyObjects.h"
35 #include "SetProperty.h"
36 #include "CloneObjects.h"
37 #include "StringMatrix.h"
38 #include "Scierror.h"
39 #include "CurrentFigure.h"
40 #include "ObjectSelection.h"
41 #include "FigureList.h"
42 #include "localization.h"
43 #include "Interaction.h"
44 #include "get_ticks_utils.h"
45 #include "HandleManagement.h"
46 #include "loadTextRenderingAPI.h"
47
48 #include "MALLOC.h"             /* MALLOC */
49 #include "Scierror.h"
50
51 #include "Format.h"             // computeDefaultTicsLabels
52
53 #include "createGraphicObject.h"
54 #include "deleteGraphicObject.h"
55 #include "returnType.h"
56 #include "getGraphicObjectProperty.h"
57 #include "setGraphicObjectProperty.h"
58 #include "graphicObjectProperties.h"
59 #include "CurrentFigure.h"
60 #include "CurrentSubwin.h"
61 #include "CurrentObject.h"
62 #include "FigureModel.h"
63 #include "AxesModel.h"
64
65 /**
66  * If a current figure exists : return it
67  * Otherwise create a new one.
68  */
69 GRAPHICS_IMPEXP char *createNewFigureWithAxes()
70 {
71     int iID = 0;
72     char *pFigureUID = NULL;
73
74     pFigureUID = cloneGraphicObject(getFigureModel());
75
76     /*
77      * Clone the default menus
78      */
79     cloneMenus(getFigureModel(), pFigureUID);
80
81     setGraphicObjectProperty(pFigureUID, __GO_ID__, &iID, jni_int, 1);
82
83     /*
84      * Clone the default axes
85      */
86     cloneAxesModel(pFigureUID);
87
88     setCurrentFigure(pFigureUID);
89
90     return pFigureUID;
91 }
92
93 /*
94  * Clone a new Axes object using the Axes model which is then
95  * attached to the newly created Figure.
96  */
97 GRAPHICS_IMPEXP void cloneAxesModel(char *pstFigureUID)
98 {
99     char *pAxesUID = cloneGraphicObject(getAxesModel());
100
101     /* Clone the Axes model's labels and attach them to the newly created Axes */
102     ConstructLabel(pAxesUID, "", 1);
103     ConstructLabel(pAxesUID, "", 2);
104     ConstructLabel(pAxesUID, "", 3);
105     ConstructLabel(pAxesUID, "", 4);
106
107     /* Sets the parent-child relationship within the MVC */
108     setGraphicObjectRelationship(pstFigureUID, pAxesUID);
109
110     /* Sets the newly created Axes as the Figure's current selected child */
111     setGraphicObjectProperty(pstFigureUID, __GO_SELECTED_CHILD__, pAxesUID, jni_string, 1);
112
113     // Set new axes as default too.
114     setCurrentObject(pAxesUID);
115     setCurrentSubWin(pAxesUID);
116 }
117
118 GRAPHICS_IMPEXP void cloneMenus(char *pModelUID, char *pCloneUID)
119 {
120     int iNbChildren = 0;
121     int *piNbChildren = &iNbChildren;
122     int iChild = 0;
123     char *pChildUID = NULL;
124     char **pChildren = NULL;
125     char *pChildType = NULL;
126
127     getGraphicObjectProperty(pModelUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&piNbChildren);
128     getGraphicObjectProperty(pModelUID, __GO_CHILDREN__, jni_string_vector, (void **)&pChildren);
129     for (iChild = iNbChildren - 1; iChild >= 0; iChild--)
130     {
131         getGraphicObjectProperty(pChildren[iChild], __GO_TYPE__, jni_string, (void **)&pChildType);
132         if (strcmp(pChildType, __GO_UIMENU__) == 0)
133         {
134             pChildUID = cloneGraphicObject(pChildren[iChild]);
135             setGraphicObjectRelationship(pCloneUID, pChildUID);
136             cloneMenus(pChildren[iChild], pChildUID);
137         }
138     }
139 }
140
141 /**
142  * If a current subwin exists: return it
143  * Otherwise create a new figure with JoGLView.
144  **/
145 GRAPHICS_IMPEXP char *getOrCreateDefaultSubwin(void)
146 {
147     char *pFigureUID = NULL;
148     char *pSubWinUID = getCurrentSubWin();
149
150     if (pSubWinUID == NULL)
151     {
152         pFigureUID = createNewFigureWithAxes();
153         setCurrentFigure(pFigureUID);
154         pSubWinUID = getCurrentSubWin();
155     }
156
157     return pSubWinUID;
158 }
159
160 /*-----------------------------------------------------------------------------*/
161
162 /**ConstructSubWin
163  * This function creates the Subwindow (the Axes) and the elementary structures.
164  * The update of color properties (foreground, background, etc.)
165  * according to the assigned parent Figure's colormap is not implemented yet.
166  * To be implemented.
167  */
168 char *ConstructSubWin(char *pparentfigureUID)
169 {
170     char *parentType = NULL;
171     char *pCloneUID = (char *)NULL;
172     char *paxesmdlUID = getAxesModel();
173
174     getGraphicObjectProperty(pparentfigureUID, __GO_TYPE__, jni_string, &parentType);
175
176     if (strcmp(parentType, __GO_FIGURE__) != 0)
177     {
178         Scierror(999, _("The parent has to be a FIGURE\n"));
179         return (char *)NULL;
180     }
181
182     pCloneUID = cloneGraphicObject(paxesmdlUID);
183
184 //    if ( sciAddNewHandle(pClone) == -1 )
185 //    {
186 //        deleteGraphicObject(pClone->UID);
187 //        FREE(pClone);
188 //        return (sciPointObj*) NULL;
189 //    }
190
191     /* Clone the Axes model's labels and attach them to the newly created Axes */
192     ConstructLabel(pCloneUID, "", 1);
193     ConstructLabel(pCloneUID, "", 2);
194     ConstructLabel(pCloneUID, "", 3);
195     ConstructLabel(pCloneUID, "", 4);
196
197     setGraphicObjectRelationship(pparentfigureUID, pCloneUID);
198
199     return pCloneUID;
200 }
201
202 /**
203  * Creates a new text object. However the object is not added in the handle list.
204  * Its graphic and font contexts are initialized.
205  * This function is to be used with objects including a text object.
206  */
207 char *allocateText(char *pparentsubwinUID,
208                    char **text,
209                    int nbRow,
210                    int nbCol,
211                    double x,
212                    double y,
213                    BOOL autoSize,
214                    double userSize[2],
215                    BOOL centerPos, int *foreground, int *background, BOOL isboxed, BOOL isline, BOOL isfilled, sciTextAlignment align)
216 {
217     char *pobjUID = NULL;
218     int textDimensions[2];
219     int visible = 0;
220     int *piVisible = &visible;
221     int clipRegionSet;
222     int *piClipRegionSet = &clipRegionSet;
223     int clipState = 0;
224     int *piClipState = &clipState;
225
226     double *clipRegion = NULL;
227     double position[3];
228     double setUserSize[2];
229
230     pobjUID = (char *)createGraphicObject(__GO_TEXT__);
231
232     /* Required to initialize the default contour properties */
233     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
234
235     /* To be implemented */
236 #if 0
237     ppText->callback = (char *)NULL;
238     ppText->callbacklen = 0;
239     ppText->callbackevent = 100;
240     ppText->visible = sciGetVisibility(pparentsubwin);
241 #endif
242
243     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
244     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
245
246     /* Clipping: to be checked for consistency */
247     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
248     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
249
250     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
251     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
252
253     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
254     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
255
256     /* Check if we should load LaTex / MathML Java libraries */
257     loadTextRenderingAPI(text, nbRow, nbCol);
258
259     /* Allocates the String array */
260     textDimensions[0] = nbRow;
261     textDimensions[1] = nbCol;
262
263     setGraphicObjectProperty(pobjUID, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
264
265     setGraphicObjectProperty(pobjUID, __GO_TEXT_STRINGS__, text, jni_string_vector, nbRow * nbCol);
266
267     position[0] = x;
268     position[1] = y;
269     position[2] = 0.0;
270
271     setGraphicObjectProperty(pobjUID, __GO_POSITION__, position, jni_double_vector, 3);
272
273     /*
274      * Possibly useless.
275      * To be deleted
276      */
277 #if 0
278     ppText->is3d = TRUE;
279 #endif
280
281     /*
282      * This was used by the previous renderer to return the Text
283      * object's bounding box, but has no present equivalent within the MVC.
284      * To be implemented when needed
285      */
286 #if 0
287     /* initialize to a not too weird value */
288     for (i = 0; i < 4; i++)
289     {
290         ppText->corners[i][0] = ppText->x;
291         ppText->corners[i][1] = ppText->y;
292         ppText->corners[i][2] = ppText->z;
293     }
294 #endif
295
296     setGraphicObjectProperty(pobjUID, __GO_TEXT_BOX_MODE__, &centerPos, jni_int, 1);
297     setGraphicObjectProperty(pobjUID, __GO_AUTO_DIMENSIONING__, &autoSize, jni_bool, 1);
298
299     /* userSize must be specified if the size is given by the user */
300     /* or the user specified a rectangle */
301     if (!autoSize || centerPos)
302     {
303         setUserSize[0] = userSize[0];
304         setUserSize[1] = userSize[1];
305     }
306     else
307     {
308         setUserSize[0] = 0.0;
309         setUserSize[1] = 0.0;
310     }
311
312     setGraphicObjectProperty(pobjUID, __GO_TEXT_BOX__, setUserSize, jni_double_vector, 2);
313
314     /* Required to get the correct MVC value from the sciTextAlignment enum */
315     align = align - 1;
316
317     /* Set alignment to left if its value is incorrect */
318     if (align < 0 || align > 2)
319     {
320         align = 0;
321     }
322
323     setGraphicObjectProperty(pobjUID, __GO_ALIGNMENT__, &align, jni_int, 1);
324
325     cloneGraphicContext(pparentsubwinUID, pobjUID);
326
327     cloneFontContext(pparentsubwinUID, pobjUID);
328
329     setGraphicObjectProperty(pobjUID, __GO_BOX__, &isboxed, jni_bool, 1);
330     setGraphicObjectProperty(pobjUID, __GO_LINE_MODE__, &isline, jni_bool, 1);
331     setGraphicObjectProperty(pobjUID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
332
333     if (foreground != NULL)
334     {
335         setGraphicObjectProperty(pobjUID, __GO_LINE_COLOR__, foreground, jni_int, 1);
336     }
337
338     if (background != NULL)
339     {
340         setGraphicObjectProperty(pobjUID, __GO_BACKGROUND__, foreground, jni_int, 1);
341     }
342
343     /* Parent reset to the null object */
344     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
345
346     return pobjUID;
347 }
348
349 /**ConstructText
350  * This function creates the parents window (manager) and the elementaries structures
351  * @param  char *pparentsubwinUID : parent subwin UID
352  * @param  char * text[] : intial text matrix string.
353  * @param  int nbCol : the number column of the text
354  * @param  int nbRow : the number of row of the text
355  * @return  : object UID if ok , NULL if not
356  */
357 char *ConstructText(char *pparentsubwinUID, char **text, int nbRow, int nbCol, double x,
358                     double y, BOOL autoSize, double userSize[2], BOOL centerPos, int *foreground, int *background,
359                     BOOL isboxed, BOOL isline, BOOL isfilled, sciTextAlignment align)
360 {
361     char *parentType = NULL;
362     char *pobjUID = NULL;
363
364     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &parentType);
365
366     if (strcmp(parentType, __GO_AXES__) != 0)
367     {
368         Scierror(999, _("The parent has to be a SUBWIN\n"));
369         return (char *)NULL;
370     }
371
372     pobjUID = allocateText(pparentsubwinUID, text, nbRow, nbCol, x, y,
373                            autoSize, userSize, centerPos, foreground, background, isboxed, isline, isfilled, align);
374
375     /* allocateText never returns NULL, to be deleted. */
376 #if 0
377     if (pobjUID == NULL)
378     {
379         return NULL;
380     }
381 #endif
382
383 //    if (sciAddNewHandle (pobj) == -1)
384 //    {
385 //        deleteGraphicObject(pobj->UID);
386 //        FREE(pobj);
387 //        return NULL;
388 //    }
389
390     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
391
392     return pobjUID;
393 }
394
395 /**ConstructLegend
396  * This function creates a Legend structure
397  * @param  char *pparentsubwinUID : parent subwin UID
398  * @param  char ** text : initial text matrix string array
399  * @param long long tabofhandles[] : the array of polyline handles
400  * @param int nblegends : the number of legend items
401  * @return : object UID if ok , NULL if not
402  */
403 char *ConstructLegend(char *pparentsubwinUID, char **text, long long tabofhandles[], int nblegends)
404 {
405     char *pobjUID = NULL;
406
407     int i = 0;
408     int iLegendPresent = 0;
409     int *piLegendPresent = &iLegendPresent;
410     int iVisible = 0;
411     int *piVisible = &iVisible;
412     int textDimensions[2];
413     int fillMode = 0;
414     int legendLocation = 0;
415
416     int clipRegionSet = 0;
417     int clipState = 0;
418
419     double *clipRegion = NULL;
420     double position[2];
421
422     char **lineIDS = NULL;
423     char *parentType = NULL;
424
425     /* Check beforehand whether a Legend object is already present */
426     getGraphicObjectProperty(pparentsubwinUID, __GO_HAS_LEGEND_CHILD__, jni_bool, &piLegendPresent);
427
428     if (iLegendPresent)
429     {
430         /* Delete it (one Legend object allowed at most) */
431         char *legendChildID;
432
433         getGraphicObjectProperty(pparentsubwinUID, __GO_LEGEND_CHILD__, jni_string, &legendChildID);
434
435         deleteGraphicObject(legendChildID);
436     }
437
438     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &parentType);
439
440     if (strcmp(parentType, __GO_AXES__) != 0)
441     {
442         Scierror(999, _("The parent has to be a SUBWIN\n"));
443         return (char *)NULL;
444     }
445
446     pobjUID = (char *)createGraphicObject(__GO_LEGEND__);
447
448     /* Required to initialize the default contour and font properties */
449     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
450
451     /* To be implemented */
452 #if 0
453     ppLegend->text.callback = (char *)NULL;
454     ppLegend->text.callbacklen = 0;
455     ppLegend->text.callbackevent = 100;
456 #endif
457
458     /* To be implemented, probably useless */
459 #if 0
460     ppLegend->text.isboxed = FALSE;
461 #endif
462
463     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
464
465     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &iVisible, jni_bool, 1);
466
467     lineIDS = (char **)MALLOC(nblegends * sizeof(char *));
468
469     if (lineIDS == NULL)
470     {
471         Scierror(999, _("%s: No more memory.\n"), "ConstructLegend");
472         return (char *)NULL;
473     }
474
475     textDimensions[0] = nblegends;
476     textDimensions[1] = 1;
477
478     setGraphicObjectProperty(pobjUID, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
479     setGraphicObjectProperty(pobjUID, __GO_TEXT_STRINGS__, text, jni_string_vector, nblegends);
480
481     for (i = 0; i < nblegends; i++)
482     {
483         char *tmpObjUID;
484
485         tmpObjUID = getObjectFromHandle((long)tabofhandles[i]);
486
487         /*
488          * Links are ordered from most recent to least recent,
489          * as their referred-to Polylines in the latter's parent Compound object.
490          */
491         lineIDS[nblegends - i - 1] = tmpObjUID;
492     }
493
494     setGraphicObjectProperty(pobjUID, __GO_LINKS__, lineIDS, jni_string_vector, nblegends);
495
496     FREE(lineIDS);
497
498     position[0] = 0.0;
499     position[1] = 0.0;
500     setGraphicObjectProperty(pobjUID, __GO_POSITION__, position, jni_double_vector, 2);
501
502     /* 9: LOWER_CAPTION */
503     legendLocation = 9;
504     setGraphicObjectProperty(pobjUID, __GO_LEGEND_LOCATION__, &legendLocation, jni_int, 1);
505
506     /* To be implemented */
507 #if 0
508     ppLegend->isselected = TRUE;
509 #endif
510
511     /* Clipping: to be checked for consistency */
512     clipRegionSet = 0;
513     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
514
515     /* 0: OFF */
516     clipState = 0;
517     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
518
519     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
520     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
521
522     /* NEW :  used to draw the line and marks of the curve F.Leray 21.01.05 */
523     cloneGraphicContext(pparentsubwinUID, pobjUID);
524
525     cloneFontContext(pparentsubwinUID, pobjUID);
526
527     fillMode = TRUE;
528     setGraphicObjectProperty(pobjUID, __GO_FILL_MODE__, &fillMode, jni_bool, 1);
529
530     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
531
532 //    if (sciAddNewHandle(pobj) == -1)
533 //    {
534 //        deleteGraphicObject(pobj->UID);
535 //        FREE(pobj);
536 //        return NULL;
537 //    }
538
539     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
540
541     return pobjUID;
542 }
543
544 /*---------------------------------------------------------------------------------*/
545 /**
546  * Create a polyline but does not add it to Scilab hierarchy
547  */
548 char *allocatePolyline(char *pparentsubwinUID, double *pvecx, double *pvecy, double *pvecz,
549                        int closed, int n1, int plot, int *foreground, int *background,
550                        int *mark_style, int *mark_foreground, int *mark_background, BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
551 {
552     char *pobjUID = NULL;
553     int i = 0;
554     BOOL result = FALSE;
555     char *type = NULL;
556     char *polylineID = NULL;
557     double barWidth = 0.;
558     double arrowSizeFactor = 0.;
559     double *clipRegion = NULL;
560     double *dataVector = NULL;
561     int clipState = 0;
562     int *piClipState = &clipState;
563     int lineClosed = 0;
564     int numElementsArray[2];
565     int visible = 0;
566     int *piVisible = &visible;
567     int zCoordinatesSet = 0;
568     int clipRegionSet = 0;
569     int *piClipRegionSet = &clipRegionSet;
570
571     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &type);
572
573     if (strcmp(type, __GO_AXES__) != 0)
574     {
575         Scierror(999, _("The parent has to be a SUBWIN\n"));
576         return NULL;
577     }
578
579     pobjUID = (char *)createGraphicObject(__GO_POLYLINE__);
580
581     polylineID = (char *)createDataObject(pobjUID, __GO_POLYLINE__);
582
583     if (polylineID == NULL)
584     {
585         deleteGraphicObject(pobjUID);
586         return NULL;
587     }
588
589     /*
590      * Sets the polyline's parent in order to initialize the former's Contoured properties
591      * with the latter's values
592      */
593     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
594
595     barWidth = 0.0;
596     setGraphicObjectProperty(pobjUID, __GO_BAR_WIDTH__, &barWidth, jni_double, 1);
597
598     /* To be implemented */
599 #if 0
600     pPOLYLINE_FEATURE(pobj)->callback = (char *)NULL;
601     pPOLYLINE_FEATURE(pobj)->callbacklen = 0;
602     pPOLYLINE_FEATURE(pobj)->callbackevent = 100;
603 #endif
604
605     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
606
607     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
608
609     /* To be deleted, see the MVC corresponding calls below */
610 #if 0
611     pPOLYLINE_FEATURE(pobj)->clip_region_set = 0;
612     sciInitIsClipping(pobj, sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)));
613     sciSetClipping(pobj, sciGetClipping(sciGetParentSubwin(pobj)));
614 #endif
615
616     /* Clip state and region */
617     /* To be checked for consistency */
618
619     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
620     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
621
622     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
623     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
624
625     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
626     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
627
628     arrowSizeFactor = 1.0;
629     setGraphicObjectProperty(pobjUID, __GO_ARROW_SIZE_FACTOR__, &arrowSizeFactor, jni_double, 1);
630
631     /* To be implemented */
632 #if 0
633     pPOLYLINE_FEATURE(pobj)->isselected = TRUE;
634 #endif
635
636     /*
637      * First element: number of gons (always 1 for a Polyline)
638      * Second one: number of vertices composing the Polyline
639      */
640     numElementsArray[0] = 1;
641     numElementsArray[1] = n1;
642
643     /* Data */
644     if (n1 != 0)
645     {
646         /*
647          * Sets the number of elements (vertices composing the polyline) and allocates the coordinates array
648          * The FALSE value is used to identify a failed memory allocation for now.
649          */
650         result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
651
652         if (result == FALSE)
653         {
654             deleteGraphicObject(pobjUID);
655             deleteDataObject(pobjUID);
656             return NULL;
657         }
658
659         dataVector = MALLOC(3 * n1 * sizeof(double));
660
661         if (dataVector == NULL)
662         {
663             deleteGraphicObject(pobjUID);
664             deleteDataObject(pobjUID);
665             return NULL;
666         }
667
668         if ((pvecx != (double *)NULL) && (pvecy != (double *)NULL))
669         {
670             for (i = 0; i < n1; i++)
671             {
672                 dataVector[i] = pvecx[i];
673                 dataVector[n1 + i] = pvecy[i];
674             }
675         }
676         else
677         {
678             for (i = 0; i < n1; i++)
679             {
680                 dataVector[i] = 0.0;
681                 dataVector[n1 + i] = 0.0;
682             }
683         }
684
685         /**DJ.Abdemouche 2003**/
686         if (pvecz == NULL)
687         {
688             for (i = 0; i < n1; i++)
689             {
690                 dataVector[2 * n1 + i] = 0.0;
691             }
692
693             zCoordinatesSet = 0;
694         }
695         else
696         {
697             for (i = 0; i < n1; i++)
698             {
699                 dataVector[2 * n1 + i] = pvecz[i];
700             }
701
702             zCoordinatesSet = 1;
703         }
704
705         /*
706          * We could probably do without the dataVector copy by individually setting
707          * x, y or z coordinates, and initializing coordinates to 0 during allocation
708          * to ensure consistency
709          */
710         setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_COORDINATES__, dataVector, jni_double, n1);
711
712         FREE(dataVector);
713
714         setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_double, n1);
715     }
716     else
717     {
718         /* 0 points */
719         result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
720
721         if (result == FALSE)
722         {
723             deleteGraphicObject(pobjUID);
724             deleteDataObject(pobjUID);
725             return NULL;
726         }
727     }
728
729     if (closed > 0)
730     {
731         lineClosed = 1;
732     }
733     else
734     {
735         lineClosed = 0;
736     }
737
738     setGraphicObjectProperty(pobjUID, __GO_CLOSED__, &lineClosed, jni_bool, 1);
739     setGraphicObjectProperty(pobjUID, __GO_POLYLINE_STYLE__, &plot, jni_int, 1);
740
741     /*
742      * Initializes the contour properties (background, foreground, etc)
743      * to the default values (those of the parent Axes).
744      */
745     cloneGraphicContext(pparentsubwinUID, pobjUID);
746
747     /* colors and marks setting */
748     setGraphicObjectProperty(pobjUID, __GO_MARK_MODE__, &ismark, jni_bool, 1);
749     setGraphicObjectProperty(pobjUID, __GO_LINE_MODE__, &isline, jni_bool, 1);
750     setGraphicObjectProperty(pobjUID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
751
752     /* shading interpolation vector and mode */
753     setGraphicObjectProperty(pobjUID, __GO_INTERP_COLOR_MODE__, &isinterpshaded, jni_bool, 1);
754
755     if (foreground != NULL)
756     {
757         setGraphicObjectProperty(pobjUID, __GO_LINE_COLOR__, foreground, jni_int, 1);
758     }
759
760     if (background != NULL)
761     {
762         if (isinterpshaded == TRUE)
763         {                       /* 3 or 4 values to store */
764
765             setGraphicObjectProperty(pobjUID, __GO_INTERP_COLOR_VECTOR__, background, jni_int_vector, n1);
766         }
767         else
768         {
769             setGraphicObjectProperty(pobjUID, __GO_BACKGROUND__, background, jni_int, 1);
770         }
771     }
772
773     if (mark_style != NULL)
774     {
775         /* This does use the MVC */
776         setGraphicObjectProperty(pobjUID, __GO_MARK_STYLE__, mark_style, jni_int, 1);
777     }
778
779     if (mark_foreground != NULL)
780     {
781         setGraphicObjectProperty(pobjUID, __GO_MARK_FOREGROUND__, mark_foreground, jni_int, 1);
782     }
783
784     if (mark_background != NULL)
785     {
786         setGraphicObjectProperty(pobjUID, __GO_MARK_BACKGROUND__, mark_background, jni_int, 1);
787     }
788
789     /* Parent reset to the null object */
790     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
791
792     visible = 1;
793     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
794
795     return pobjUID;
796 }
797
798 /*---------------------------------------------------------------------------------*/
799 /**ConstructPolyline
800  * This function creates  Polyline 2d structure
801  */
802 char *ConstructPolyline(char *pparentsubwinUID, double *pvecx, double *pvecy, double *pvecz,
803                         int closed, int n1, int plot, int *foreground, int *background,
804                         int *mark_style, int *mark_foreground, int *mark_background, BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
805 {
806     char *pobjUID = allocatePolyline(pparentsubwinUID, pvecx, pvecy, pvecz, closed, n1, plot,
807                                      foreground, background, mark_style, mark_foreground, mark_background,
808                                      isline, isfilled, ismark, isinterpshaded);
809
810     if (pobjUID == NULL)
811     {
812         return NULL;
813     }
814
815 //  if (sciAddNewHandle(pobj) == -1)
816 //  {
817 //    deleteGraphicObject(pobj->UID);
818 //    deleteDataObject(pobj->UID);
819 //    FREE(pobj);
820 //    return NULL;
821 //  }
822
823     /*
824      * Sets the Axes as the polyline's parent and adds the polyline to
825      * its parent's list of children.
826      */
827     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
828
829     return pobjUID;
830 }
831
832 /**ConstructArc
833  * This function creates an Arc structure
834  */
835 char *ConstructArc(char *pparentsubwinUID, double x, double y,
836                    double height, double width, double alphabegin, double alphaend, int *foreground, int *background, BOOL isfilled, BOOL isline)
837 {
838     char *pobjUID = NULL;
839     char *type = NULL;
840     double upperLeftPoint[3];
841     double *clipRegion = NULL;
842     int visible = 0;
843     int *piVisible = &visible;
844     int arcDrawingMethod = 0;
845     int *piArcDrawingMethod = &arcDrawingMethod;
846     int clipRegionSet = 0;
847     int *piClipRegionSet = &clipRegionSet;
848     int clipState = 0;
849     int *piClipState = &clipState;
850
851     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &type);
852
853     if (strcmp(type, __GO_AXES__) != 0)
854     {
855         Scierror(999, _("The parent has to be a SUBWIN\n"));
856         return (char *)NULL;
857     }
858
859     pobjUID = (char *)createGraphicObject(__GO_ARC__);
860
861     /*
862      * Sets the arc's parent in order to initialize the former's Contoured properties
863      * with the latter's values (cloneGraphicContext call below)
864      */
865     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
866
867     /* To be implemented */
868 #if 0
869     ppArc->callback = (char *)NULL;
870     ppArc->callbacklen = 0;
871     ppArc->callbackevent = 100;
872 #endif
873
874     upperLeftPoint[0] = x;
875     upperLeftPoint[1] = y;
876     upperLeftPoint[2] = 0.0;
877
878     setGraphicObjectProperty(pobjUID, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
879
880     setGraphicObjectProperty(pobjUID, __GO_HEIGHT__, &height, jni_double, 1);
881     setGraphicObjectProperty(pobjUID, __GO_WIDTH__, &width, jni_double, 1);
882
883     setGraphicObjectProperty(pobjUID, __GO_START_ANGLE__, &alphabegin, jni_double, 1);
884     setGraphicObjectProperty(pobjUID, __GO_END_ANGLE__, &alphaend, jni_double, 1);
885
886     /* To be implemented */
887 #if 0
888     ppArc->isselected = TRUE;
889 #endif
890
891     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
892
893     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
894
895     getGraphicObjectProperty(pparentsubwinUID, __GO_ARC_DRAWING_METHOD__, jni_int, &piArcDrawingMethod);
896
897     setGraphicObjectProperty(pobjUID, __GO_ARC_DRAWING_METHOD__, &arcDrawingMethod, jni_int, 1);
898
899     /* To be checked for consistency */
900 #if 0
901     ppArc->clip_region_set = 0;
902     /*ppArc->isclip = sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)); */
903     sciInitIsClipping(pobj, sciGetIsClipping(pparentsubwin));
904     sciSetClipping(pobj, sciGetClipping(pparentsubwin));
905     /*      pARC_FEATURE (pobj)->clip_region = (double *) NULL; */
906 #endif
907
908     /*
909      * Clip state and region
910      * To be checked for consistency
911      */
912     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
913     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
914
915     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
916     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
917
918     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
919     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
920
921     /*
922      * Initializes the contour properties (background, foreground, etc)
923      * to the parent Axes' values.
924      */
925     cloneGraphicContext(pparentsubwinUID, pobjUID);
926
927     /* Contour settings */
928     setGraphicObjectProperty(pobjUID, __GO_LINE_MODE__, &isline, jni_bool, 1);
929     setGraphicObjectProperty(pobjUID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
930
931     if (foreground != NULL)
932     {
933         setGraphicObjectProperty(pobjUID, __GO_LINE_COLOR__, foreground, jni_int, 1);
934     }
935
936     if (background != NULL)
937     {
938         setGraphicObjectProperty(pobjUID, __GO_BACKGROUND__, background, jni_int, 1);
939     }
940
941     /* Parent reset to the null object */
942     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
943
944 //    if (sciAddNewHandle(pobj) == -1)
945 //    {
946 //        deleteGraphicObject(pobj->UID);
947 //        FREE(pobj);
948 //        return NULL;
949 //    }
950
951     /*
952      * Sets the Axes as the arc's parent and adds the arc to
953      * its parent's list of children.
954      */
955     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
956
957     return pobjUID;
958 }
959
960 /**ConstructRectangle
961  * This function creates Rectangle structure and only this to destroy all sons use DelGraphicsSon
962  */
963 char *ConstructRectangle(char *pparentsubwinUID, double x, double y,
964                          double height, double width, int *foreground, int *background, int isfilled, int isline)
965 {
966     char *pobjUID = NULL;
967     char *type = NULL;
968     double upperLeftPoint[3];
969     double *clipRegion = NULL;
970     int visible = 0;
971     int *piVisible = &visible;
972     int clipRegionSet = 0;
973     int *piClipRegionSet = &clipRegionSet;
974     int clipState = 0;
975     int *piClipState = &clipState;
976
977     if (height < 0.0 || width < 0.0)
978     {
979         Scierror(999, _("Width and height must be positive.\n"));
980         return NULL;
981     }
982
983     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &type);
984
985     if (strcmp(type, __GO_AXES__) != 0)
986     {
987         Scierror(999, _("The parent has to be a SUBWIN\n"));
988         return (char *)NULL;
989     }
990
991     pobjUID = (char *)createGraphicObject(__GO_RECTANGLE__);
992
993     /*
994      * Sets the rectangle's parent in order to initialize the former's Contoured properties
995      * with the latter's values (cloneGraphicContext call below)
996      */
997     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
998
999     /* To be implemented */
1000 #if 0
1001     pRECTANGLE_FEATURE(pobj)->callback = (char *)NULL;
1002     pRECTANGLE_FEATURE(pobj)->callbacklen = 0;
1003     pRECTANGLE_FEATURE(pobj)->callbackevent = 100;
1004 #endif
1005
1006     upperLeftPoint[0] = x;
1007     upperLeftPoint[1] = y;
1008     upperLeftPoint[2] = 0.0;
1009
1010     setGraphicObjectProperty(pobjUID, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
1011
1012     setGraphicObjectProperty(pobjUID, __GO_HEIGHT__, &height, jni_double, 1);
1013     setGraphicObjectProperty(pobjUID, __GO_WIDTH__, &width, jni_double, 1);
1014
1015     /* To be implemented */
1016 #if 0
1017     pRECTANGLE_FEATURE(pobj)->isselected = TRUE;
1018 #endif
1019
1020     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
1021     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
1022
1023     /* Clipping: to be checked */
1024 #if 0
1025     pRECTANGLE_FEATURE(pobj)->clip_region_set = 0;
1026     sciInitIsClipping(pobj, sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)));
1027     sciSetClipping(pobj, sciGetClipping(sciGetParentSubwin(pobj)));
1028 #endif
1029
1030     /* Clip state and region */
1031     /* To be checked for consistency */
1032
1033     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1034     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1035
1036     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1037     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1038
1039     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
1040     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1041
1042     /*
1043      * Initializes the contour properties (background, foreground, etc)
1044      * to the default values (those of the parent Axes).
1045      */
1046     cloneGraphicContext(pparentsubwinUID, pobjUID);
1047
1048     /* Contour settings */
1049     setGraphicObjectProperty(pobjUID, __GO_LINE_MODE__, &isline, jni_bool, 1);
1050     setGraphicObjectProperty(pobjUID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
1051
1052     if (foreground != NULL)
1053     {
1054         setGraphicObjectProperty(pobjUID, __GO_LINE_COLOR__, foreground, jni_int, 1);
1055     }
1056
1057     if (background != NULL)
1058     {
1059         setGraphicObjectProperty(pobjUID, __GO_BACKGROUND__, background, jni_int, 1);
1060     }
1061
1062     /* Parent reset to the null object */
1063     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
1064
1065 //    if (sciAddNewHandle(pobj) == -1)
1066 //    {
1067 //        deleteGraphicObject(pobj->UID);
1068 //        FREE(pobj);
1069 //        return NULL;
1070 //    }
1071
1072     /*
1073      * Sets the Axes as the rectangle's parent and adds the rectangle to
1074      * its parent's list of children.
1075      */
1076     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
1077
1078     return pobjUID;
1079 }
1080
1081 /**ConstructSurface
1082  * This function creates Surface Structure
1083  */
1084 char *ConstructSurface(char *pparentsubwinUID, sciTypeOf3D typeof3d,
1085                        double *pvecx, double *pvecy, double *pvecz, double *zcol,
1086                        int izcol, int dimzx, int dimzy,
1087                        int *flag, double *ebox, int flagcolor, int *isfac, int *m1, int *n1, int *m2, int *n2, int *m3, int *n3, int *m3n, int *n3n)
1088 {
1089     char *pobjUID = NULL;
1090     char *parentType = NULL;
1091     char *surfaceID = NULL;
1092     char *surfaceTypes[2] = { __GO_PLOT3D__, __GO_FAC3D__ };
1093
1094     double *clipRegion = NULL;
1095
1096     int nx = 0, ny = 0, nz = 0, nc = 0;
1097     int result = 0;
1098     int clipRegionSet = 0;
1099     int *piClipRegionSet = &clipRegionSet;
1100     int clipState = 0;
1101     int *piClipState = &clipState;
1102     int visible = 0;
1103     int *piVisible = &visible;
1104     int cdataMapping = 0;
1105     int hiddenColor = 0;
1106     int *piHiddenColor = &hiddenColor;
1107     int surfaceMode = 0;
1108
1109     /* To be modified: the MVC does not allow Plot3d objects with color data yet */
1110     if (typeof3d == SCI_PLOT3D)
1111     {
1112         nx = dimzx;
1113         ny = dimzy;
1114         nz = dimzx * dimzy;
1115         if (flagcolor == 2)
1116         {
1117             /* one color per facet: nc = dimzx * dimzy */
1118             nc = nz;
1119         }
1120         else if (flagcolor == 3)
1121         {
1122             /*
1123              * one color per edge: nc = 4* dimzx * dimzy ??????
1124              * 3 or 4 vertices are needed: I think we take 4 to have enough allocated memory
1125              */
1126             nc = nz * 4;
1127         }
1128         /* made by Djalel : comes from the genfac3d case */
1129         else
1130         {
1131             nc = 0;
1132         }
1133     }
1134     /* DJ.A 2003 */
1135     else
1136     {                           /* case SCI_FAC3D */
1137         nx = dimzx * dimzy;
1138         ny = dimzx * dimzy;
1139         nz = dimzx * dimzy;
1140         if (flagcolor == 2)
1141         {
1142             /* one color per facet: nc = dimzy */
1143             nc = dimzy;
1144         }
1145         else if (flagcolor == 3)
1146         {
1147             /* one color per edge: nc = dimzx * dimzy */
1148             nc = nz;
1149         }
1150         else
1151         {
1152             nc = 0;
1153         }
1154     }
1155
1156     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &parentType);
1157
1158     /* test using sciGetEntityType replaced by a test on the type string */
1159     if (strcmp(parentType, __GO_AXES__) != 0)
1160     {
1161         Scierror(999, _("The parent has to be a SUBWIN\n"));
1162         return NULL;
1163     }
1164
1165     /* To be implemented */
1166 #if 0
1167     psurf->callback = (char *)NULL;
1168     psurf->callbacklen = 0;
1169     psurf->callbackevent = 100;
1170 #endif
1171
1172     pobjUID = (char *)createGraphicObject(surfaceTypes[*isfac]);
1173     surfaceID = (char *)createDataObject(pobjUID, surfaceTypes[*isfac]);
1174
1175     /*Adding F.Leray 19.03.04 */
1176     /* Dimension of the color matrix, to be implemented (vector case) */
1177 #if 0
1178     psurf->m3n = *m3n;
1179     psurf->n3n = *n3n;
1180 #endif
1181
1182     /* Clip state and region */
1183     /* To be checked for consistency */
1184
1185     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1186     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1187
1188     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1189     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1190
1191     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
1192     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1193
1194     /* Visibility */
1195     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
1196
1197     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
1198
1199     setGraphicObjectProperty(pobjUID, __GO_COLOR_FLAG__, &flagcolor, jni_int, 1);
1200
1201     /* Direct mode enabled as default */
1202     cdataMapping = 1;
1203
1204     /* Only for Fac3D */
1205     setGraphicObjectProperty(pobjUID, __GO_DATA_MAPPING__, &cdataMapping, jni_int, 1);
1206
1207     setGraphicObjectProperty(pobjUID, __GO_COLOR_MODE__, &flag[0], jni_int, 1);
1208
1209     /* Plot3d case */
1210     if (!*isfac)
1211     {
1212         int gridSize[4];
1213
1214         gridSize[0] = *m1;
1215         gridSize[1] = *n1;
1216         gridSize[2] = *m2;
1217         gridSize[3] = *n2;
1218
1219         /* Allocates the coordinates arrays */
1220         result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
1221     }
1222     /* Fac3d case */
1223     else
1224     {
1225         int numElementsArray[3];
1226
1227         /*
1228          * First element: number of n-gons
1229          * Second element: number of vertices per n-gon
1230          * Third element: number of input colors
1231          */
1232         numElementsArray[0] = dimzy;
1233         numElementsArray[1] = dimzx;
1234         numElementsArray[2] = nc;
1235
1236         /* Allocates the coordinates and color arrays */
1237         result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 3);
1238     }
1239
1240     if (result == 0)
1241     {
1242         deleteGraphicObject(pobjUID);
1243         deleteDataObject(pobjUID);
1244         return NULL;
1245     }
1246
1247     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, nx);
1248     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, ny);
1249     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Z__, pvecz, jni_double_vector, nz);
1250
1251     /* Add the color matrix dimensions as a property ? */
1252     if (nc > 0)
1253     {
1254         setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_COLORS__, zcol, jni_double_vector, nc);
1255     }
1256
1257     /*-------END Replaced by: --------*/
1258
1259     /* To be implemented */
1260 #if 0
1261     psurf->isselected = TRUE;
1262 #endif
1263
1264     /* The flag array is apparently now useless (flag[0] == COLOR_MODE, the two remaining ones are unused) */
1265 #if 0
1266     psurf->flag[0] = flag[0];   /* F.Leray 16.04.04 HERE We store the flag=[mode (hidden part ), type (scaling), box (frame around the plot)] */
1267     psurf->flag[1] = flag[1];
1268     psurf->flag[2] = flag[2];
1269 #endif
1270
1271     /* DJ.A 2003 */
1272     /* Apparently useless */
1273 #if 0
1274     psurf->ebox[0] = ebox[0];
1275     psurf->ebox[1] = ebox[1];
1276     psurf->ebox[2] = ebox[2];
1277     psurf->ebox[3] = ebox[3];
1278     psurf->ebox[4] = ebox[4];
1279     psurf->ebox[5] = ebox[5];
1280 #endif
1281
1282     getGraphicObjectProperty(pparentsubwinUID, __GO_HIDDEN_COLOR__, jni_int, &piHiddenColor);
1283     setGraphicObjectProperty(pobjUID, __GO_HIDDEN_COLOR__, &hiddenColor, jni_int, 1);
1284
1285     /*
1286      * surfaceMode set to "on", was previously done by InitGraphicContext, by setting
1287      * the graphic context's line_mode to on, which stood for the surface_mode.
1288      */
1289     surfaceMode = 1;
1290
1291     setGraphicObjectProperty(pobjUID, __GO_SURFACE_MODE__, &surfaceMode, jni_bool, 1);
1292
1293     /*
1294      * Adding a new handle and setting the parent-child relationship is now
1295      * done after data initialization in order to avoid additional
1296      * clean-up.
1297      */
1298 //    if (sciAddNewHandle(pobj) == -1)
1299 //    {
1300 //        deleteGraphicObject(pobj->UID);
1301 //        deleteDataObject(pobj->UID);
1302 //        FREE(pobj);
1303 //        return (sciPointObj*) NULL;
1304 //    }
1305
1306     // Here we init old 'graphicContext' by cloning it from parent.
1307     cloneGraphicContext(pparentsubwinUID, pobjUID);
1308     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
1309
1310     return pobjUID;
1311 }
1312
1313 /********************** 14/05/2002 *****
1314  **ConstructGrayplot
1315  * This function is used to build Grayplot and Matplot objects.
1316  * It would probably be better to put the code related to Matplot objects
1317  * in a separate build function, as it would avoid having to perform several tests
1318  * on the type parameter. This is done so because Matplot objects were previously
1319  * internally represented by sciGrayplot structures.
1320  */
1321 char *ConstructGrayplot(char *pparentsubwinUID, double *pvecx, double *pvecy, double *pvecz, int n1, int n2, int type)
1322 {
1323     char *pobjUID = NULL;
1324
1325     char *objectTypes[3] = { __GO_GRAYPLOT__, __GO_MATPLOT__, __GO_MATPLOT__ };
1326
1327     char *typeParent = NULL;
1328     char *grayplotID = NULL;
1329     int result = 0;
1330     int dataMapping = 0;
1331     int gridSize[4];
1332
1333     int parentVisible = 0;
1334     int *piParentVisible = &parentVisible;
1335     double *clipRegion = NULL;
1336     int clipRegionSet = 0;
1337     int *piClipRegionSet = &clipRegionSet;
1338     int clipState = 0;
1339     int *piClipState = &clipState;
1340     int numElements = 0;
1341
1342     double pdblScale[2];
1343
1344     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &typeParent);
1345
1346     if (strcmp(typeParent, __GO_AXES__) != 0)
1347     {
1348         Scierror(999, _("The parent has to be a SUBWIN\n"));
1349         return (char *)NULL;
1350     }
1351
1352     pobjUID = (char *)createGraphicObject(objectTypes[type]);
1353     grayplotID = (char *)createDataObject(pobjUID, objectTypes[type]);
1354
1355     if (grayplotID == NULL)
1356     {
1357         deleteGraphicObject(pobjUID);
1358         return (char *)NULL;
1359     }
1360
1361     /* To be implemented */
1362 #if 0
1363     pGRAYPLOT_FEATURE(pobj)->callback = (char *)NULL;
1364     pGRAYPLOT_FEATURE(pobj)->callbacklen = 0;
1365     pGRAYPLOT_FEATURE(pobj)->callbackevent = 100;
1366
1367     pGRAYPLOT_FEATURE(pobj)->isselected = TRUE;
1368 #endif
1369
1370     /* 0: scaled; only used for Grayplot */
1371     if (type == 0)
1372     {
1373         dataMapping = 0;
1374         setGraphicObjectProperty(pobjUID, __GO_DATA_MAPPING__, &dataMapping, jni_int, 1);
1375     }
1376
1377     /* The x and y vectors are column ones */
1378
1379     /*
1380      * For the Grayplot object, the number of rows and columns respectively
1381      * correspond to the grid's x and y dimensions whereas for Matplot objects,
1382      * they respectively correspond to the grid's y and x dimensions.
1383      */
1384     if (type == 0)
1385     {
1386         gridSize[0] = n1;
1387         gridSize[1] = 1;
1388         gridSize[2] = n2;
1389         gridSize[3] = 1;
1390     }
1391     else
1392     {
1393         gridSize[0] = n2;
1394         gridSize[1] = 1;
1395         gridSize[2] = n1;
1396         gridSize[3] = 1;
1397     }
1398
1399     /* Only for Matplot1 objects */
1400     if (type == 2)
1401     {
1402         setGraphicObjectProperty(pobjUID, __GO_MATPLOT_TRANSLATE__, pvecx, jni_double_vector, 2);
1403         pdblScale[0] = (pvecx[2] - pvecx[0]) / (n1 - 1);
1404         pdblScale[1] = (pvecx[3] - pvecx[1]) / (n2 - 1);
1405         setGraphicObjectProperty(pobjUID, __GO_MATPLOT_SCALE__, pdblScale, jni_double_vector, 2);
1406     }
1407
1408     /* Allocates the coordinates arrays */
1409     result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
1410
1411     if (result == 0)
1412     {
1413         deleteGraphicObject(pobjUID);
1414         deleteDataObject(pobjUID);
1415         return (char *)NULL;
1416     }
1417
1418     /* Only for Grayplot objects, for Matplot objects, x and y coordinates are automatically computed */
1419     if (type == 0)
1420     {
1421         setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, n1);
1422         setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, n2);
1423     }
1424
1425     if (type == 0)
1426     {
1427         numElements = n1 * n2;
1428     }
1429     else
1430     {
1431         numElements = (n1 - 1) * (n2 - 1);
1432     }
1433
1434     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Z__, pvecz, jni_double_vector, numElements);
1435
1436     /*
1437      * Adding a new handle and setting the parent-child relationship is now
1438      * done after data initialization in order to avoid additional
1439      * clean-up.
1440      */
1441 //    if (sciAddNewHandle(pobj) == -1)
1442 //    {
1443 //        deleteGraphicObject(pobj->UID);
1444 //        FREE(pobj);
1445 //        return (sciPointObj*) NULL;
1446 //    }
1447
1448     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
1449
1450     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piParentVisible);
1451     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
1452
1453     /*
1454      * Clip state and region
1455      * To be checked for consistency
1456      */
1457     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1458     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1459
1460     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1461     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1462
1463     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
1464     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1465
1466     /* Initializes the default Contour values */
1467     cloneGraphicContext(pparentsubwinUID, pobjUID);
1468
1469     return pobjUID;
1470 }
1471
1472 /**ConstructAxis
1473  * This function creates an Axis object
1474  * @author Djalel ABDEMOUCHE
1475  * @see sciSetCurrentObj
1476  *
1477  */
1478 char *ConstructAxis(char *pparentsubwinUID, char dir, char tics, double *vx,
1479                     int nx, double *vy, int ny, char **str, int subint, char *format,
1480                     int fontsize, int textcolor, int ticscolor, char logscale, int seg, int nb_tics_labels)
1481 {
1482     char *parentType = NULL;
1483     char *pobjUID = NULL;
1484     int i = 0;
1485     int clipRegionSet = 0;
1486     int clipState = 0;
1487     int ticksDirection = 0;
1488     int ticksStyle = 0;
1489     double *clipRegion = NULL;
1490     double doubleFontSize = 0.;
1491
1492     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &parentType);
1493
1494     if (strcmp(parentType, __GO_AXES__) != 0)
1495     {
1496         Scierror(999, _("The parent has to be a SUBWIN\n"));
1497         return (char *)NULL;
1498     }
1499
1500     pobjUID = (char *)createGraphicObject(__GO_AXIS__);
1501
1502     /* Required to initialize the default contour properties */
1503     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
1504
1505     /* To be implemented */
1506 #if 0
1507     pAXES_FEATURE(pobj)->callback = (char *)NULL;
1508     pAXES_FEATURE(pobj)->callbacklen = 0;
1509     pAXES_FEATURE(pobj)->callbackevent = 100;
1510     pAXES_FEATURE(pobj)->visible = sciGetVisibility(sciGetParentSubwin(pobj));
1511 #endif
1512
1513     /* Clipping: to be checked for consistency */
1514     clipRegionSet = 0;
1515     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1516
1517     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1518     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1519
1520     /* 0: OFF */
1521     clipState = 0;
1522     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1523
1524     /* The ticks style and direction MVC properties are Integers */
1525     if (dir == 'u')
1526     {
1527         ticksDirection = 0;
1528     }
1529     else if (dir == 'd')
1530     {
1531         ticksDirection = 1;
1532     }
1533     else if (dir == 'l')
1534     {
1535         ticksDirection = 2;
1536     }
1537     else if (dir == 'r')
1538     {
1539         ticksDirection = 3;
1540     }
1541     else
1542     {
1543         ticksDirection = 0;
1544     }
1545
1546     if (tics == 'v')
1547     {
1548         ticksStyle = 0;
1549     }
1550     else if (tics == 'r')
1551     {
1552         ticksStyle = 1;
1553     }
1554     else if (tics == 'i')
1555     {
1556         ticksStyle = 2;
1557     }
1558     else
1559     {
1560         ticksStyle = 0;
1561     }
1562
1563     setGraphicObjectProperty(pobjUID, __GO_TICKS_DIRECTION__, &ticksDirection, jni_int, 1);
1564     setGraphicObjectProperty(pobjUID, __GO_TICKS_STYLE__, &ticksStyle, jni_int, 1);
1565
1566     setGraphicObjectProperty(pobjUID, __GO_X_TICKS_COORDS__, vx, jni_double_vector, nx);
1567     setGraphicObjectProperty(pobjUID, __GO_Y_TICKS_COORDS__, vy, jni_double_vector, ny);
1568
1569     /* FORMATN must be set before Labels are computed. */
1570     if (format != NULL)
1571     {
1572         setGraphicObjectProperty(pobjUID, __GO_FORMATN__, format, jni_string, 1);
1573     }
1574
1575     /*
1576      * Labels are computed automatically depending on the ticks coordinates.
1577      * The computation is performed by a C function which has been adapted
1578      * to the MVC (property get calls) and was previously done in the
1579      * tics labels property get C function.
1580      * It should be done (or called) directly in the Java part of the model
1581      * for the sake of efficiency.
1582      * To be modified
1583      */
1584     if (str == NULL)
1585     {
1586         char **matData;
1587         StringMatrix *tics_labels;
1588
1589         tics_labels = computeDefaultTicsLabels(pobjUID);
1590
1591         if (tics_labels == NULL)
1592         {
1593             deleteGraphicObject(pobjUID);
1594             return (char *)NULL;
1595         }
1596
1597         matData = getStrMatData(tics_labels);
1598
1599         /*
1600          * The labels vector size must be computed using the matrix's dimensions.
1601          * To be modified when the labels computation is moved to the Model.
1602          */
1603         setGraphicObjectProperty(pobjUID, __GO_TICKS_LABELS__, matData, jni_string_vector, tics_labels->nbCol * tics_labels->nbRow);
1604
1605         deleteMatrix(tics_labels);
1606     }
1607     else
1608     {
1609         /*
1610          * Labels are set using the str argument; the previous code tested whether each element of the
1611          * str array was null and set the corresponding Axis' element to NULL, though there was no
1612          * apparent reason to do so. This is still checked, but now aborts building the Axis.
1613          */
1614
1615         if (nb_tics_labels == -1)
1616         {
1617             Scierror(999, _("Impossible case when building axis\n"));
1618             deleteGraphicObject(pobjUID);
1619             return (char *)NULL;
1620         }
1621
1622         for (i = 0; i < nb_tics_labels; i++)
1623         {
1624             if (str[i] == NULL)
1625             {
1626                 deleteGraphicObject(pobjUID);
1627                 return (char *)NULL;
1628             }
1629         }
1630
1631         setGraphicObjectProperty(pobjUID, __GO_TICKS_LABELS__, str, jni_string_vector, nb_tics_labels);
1632     }
1633
1634     setGraphicObjectProperty(pobjUID, __GO_SUBTICKS__, &subint, jni_int, 1);
1635     setGraphicObjectProperty(pobjUID, __GO_TICKS_SEGMENT__, &seg, jni_bool, 1);
1636
1637     /* Initializes the default Contour values */
1638     cloneGraphicContext(pparentsubwinUID, pobjUID);
1639
1640     /* Initializes the default Font values */
1641     cloneFontContext(pparentsubwinUID, pobjUID);
1642
1643     /* Parent reset to the null object */
1644     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
1645
1646 //    if (sciAddNewHandle(pobj) == -1)
1647 //    {
1648 //        deleteGraphicObject(pobj->UID);
1649 //        deleteDataObject(pobj->UID);
1650 //        FREE(pobj);
1651 //        return (sciPointObj*) NULL;
1652 //    }
1653
1654     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
1655
1656     doubleFontSize = (double)fontsize;
1657
1658     setGraphicObjectProperty(pobjUID, __GO_FONT_SIZE__, &doubleFontSize, jni_double, 1);
1659     setGraphicObjectProperty(pobjUID, __GO_FONT_COLOR__, &textcolor, jni_int, 1);
1660     setGraphicObjectProperty(pobjUID, __GO_TICKS_COLOR__, &ticscolor, jni_int, 1);
1661
1662     return pobjUID;
1663 }
1664
1665 /********************** 21/05/2002 *****
1666  **ConstructFec
1667  * This function creates Fec
1668  * @author Djalel.ABDEMOUCHE
1669  * @see sciSetCurrentObj
1670  */
1671 char *ConstructFec(char *pparentsubwinUID, double *pvecx, double *pvecy, double *pnoeud,
1672                    double *pfun, int Nnode, int Ntr, double *zminmax, int *colminmax, int *colout, BOOL with_mesh)
1673 {
1674     char *pobjUID = NULL;
1675     char *fecId = NULL;
1676     int result = 0;
1677
1678     char *parentType = NULL;
1679     int parentVisible = 0;
1680     int *piParentVisible = &parentVisible;
1681
1682     double *clipRegion = NULL;
1683     int clipRegionSet = 0;
1684     int *piClipRegionSet = &clipRegionSet;
1685     int iClipState = 0;
1686     int *piClipState = &iClipState;
1687
1688     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, (void **)&parentType);
1689
1690     /* test using sciGetEntityType replaced by a test on the type string */
1691     if (strcmp(parentType, __GO_AXES__) != 0)
1692     {
1693         Scierror(999, _("The parent has to be a SUBWIN\n"));
1694         return (char *)NULL;
1695     }
1696
1697     pobjUID = createGraphicObject(__GO_FEC__);
1698     fecId = (char *)createDataObject(pobjUID, __GO_FEC__);
1699
1700     if (fecId == NULL)
1701     {
1702         deleteGraphicObject(pobjUID);
1703         return (char *)NULL;
1704     }
1705
1706     /* To be implemented */
1707 #if 0
1708     pFEC_FEATURE(pobj)->callback = (char *)NULL;
1709     pFEC_FEATURE(pobj)->callbacklen = 0;
1710     pFEC_FEATURE(pobj)->callbackevent = 100;
1711
1712     pFEC_FEATURE(pobj)->isselected = TRUE;
1713 #endif
1714
1715     /* Allocates the coordinates array */
1716     result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_VERTICES__, &Nnode, jni_int, 1);
1717
1718     if (result == 0)
1719     {
1720         deleteGraphicObject(pobjUID);
1721         deleteDataObject(pobjUID);
1722         return (char *)NULL;
1723     }
1724
1725     /* Allocates the triangle indices and values array */
1726     result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_INDICES__, &Ntr, jni_int, 1);
1727
1728     if (result == 0)
1729     {
1730         deleteGraphicObject(pobjUID);
1731         deleteDataObject(pobjUID);
1732         return (char *)NULL;
1733     }
1734
1735     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, Nnode);
1736     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, Nnode);
1737
1738     /* Fec-specific property: triangle indices plus special values (triangle number and flag) */
1739     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_FEC_TRIANGLES__, pnoeud, jni_double_vector, Ntr);
1740
1741     /* Function values */
1742     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_VALUES__, pfun, jni_double_vector, Nnode);
1743
1744     setGraphicObjectProperty(pobjUID, __GO_Z_BOUNDS__, zminmax, jni_double_vector, 2);
1745     setGraphicObjectProperty(pobjUID, __GO_COLOR_RANGE__, colminmax, jni_int_vector, 2);
1746     setGraphicObjectProperty(pobjUID, __GO_OUTSIDE_COLOR__, colout, jni_int_vector, 2);
1747
1748     /*
1749      * Adding a new handle and setting the parent-child relationship is now
1750      * done after data initialization in order to avoid additional
1751      * clean-up.
1752      */
1753 //    if (sciAddNewHandle(pobj) == -1)
1754 //    {
1755 //        deleteGraphicObject(pobj->UID);
1756 //        deleteDataObject(pobj->UID);
1757 //        FREE(pobj);
1758 //        return (sciPointObj*) NULL;
1759 //    }
1760
1761     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
1762
1763     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, (void **)&piParentVisible);
1764     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
1765
1766     /* Clipping: to be checked */
1767 #if 0
1768     sciInitIsClipping(pobj, sciGetIsClipping(pparentsubwin));
1769     sciSetClipping(pobj, sciGetClipping(pparentsubwin));
1770 #endif
1771
1772     /*
1773      * Clip state and region
1774      * To be checked for consistency
1775      */
1776     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, (void **)&clipRegion);
1777     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1778
1779     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, (void **)&piClipRegionSet);
1780     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1781
1782     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, (void **)&piClipState);
1783     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
1784
1785     /* Initializes the default Contour values */
1786     cloneGraphicContext(pparentsubwinUID, pobjUID);
1787
1788     /* line mode is set using with_mesh */
1789     setGraphicObjectProperty(pobjUID, __GO_LINE_MODE__, &with_mesh, jni_bool, 1);
1790
1791     return pobjUID;
1792 }
1793
1794 /**ConstructSegs
1795  * This function creates Segments
1796  * It is used to create and initialize the data of both the Champ and Segs MVC objects.
1797  * @author Djalel.ABDEMOUCHE
1798  * @version 0.1
1799  * @see sciSetCurrentObj
1800  */
1801 char *ConstructSegs(char *pparentsubwinUID, int type,
1802                     double *vx, double *vy, double *vz,
1803                     int Nbr1, int Nbr2, int Nbr3, double *vfx, double *vfy, int flag, int *style, double arsize, int colored, int typeofchamp)
1804 {
1805     char *pobjUID = NULL;
1806
1807     int visible = 0;
1808     int *piVisible = &visible;
1809     int clipRegionSet = 0;
1810     int *piClipRegionSet = &clipRegionSet;
1811     int clipState = 0;
1812     int *piClipState = &clipState;
1813     int numberArrows = 0;
1814     int dimensions[2];
1815     int i = 0;
1816
1817     double *clipRegion = NULL;
1818     double *arrowCoords = NULL;
1819
1820     if (type == 0)
1821     {
1822         pobjUID = createGraphicObject(__GO_SEGS__);
1823     }
1824     else if (type == 1)
1825     {
1826         pobjUID = createGraphicObject(__GO_CHAMP__);
1827     }
1828     else
1829     {
1830         return (char *)NULL;
1831     }
1832
1833     /* To be implemented */
1834 #if 0
1835     ppSegs->callback = (char *)NULL;
1836     ppSegs->callbacklen = 0;
1837     ppSegs->callbackevent = 100;
1838
1839     ppSegs->isselected = TRUE;
1840 #endif
1841
1842     getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
1843
1844     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
1845
1846     /* this must be done prior to the call of sciSetClipping to know */
1847     /* if the clip_state has been set */
1848
1849     /*
1850      * Clip state and region
1851      * To be checked for consistency
1852      */
1853     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, (void **)&clipRegion);
1854     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1855
1856     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, (void **)&piClipRegionSet);
1857     setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1858
1859     getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, (void **)&piClipState);
1860     setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1861
1862     if (type == 1)
1863     {
1864         numberArrows = Nbr1 * Nbr2;
1865     }
1866     else
1867     {
1868         /* Segs: Nbr1/2 arrows, Nbr1 is the number of endpoints */
1869         numberArrows = Nbr1 / 2;
1870     }
1871
1872     /* Triggers the creation of the Arrow objects part of Champ or Segs */
1873     setGraphicObjectProperty(pobjUID, __GO_NUMBER_ARROWS__, &numberArrows, jni_int, 1);
1874
1875     /* Champ property only */
1876     if (type == 1)
1877     {
1878         dimensions[0] = Nbr1;
1879         dimensions[1] = Nbr2;
1880
1881         setGraphicObjectProperty(pobjUID, __GO_CHAMP_DIMENSIONS__, dimensions, jni_int_vector, 2);
1882     }
1883
1884     arrowCoords = (double *)MALLOC(3 * numberArrows * sizeof(double));
1885
1886     if (arrowCoords == NULL)
1887     {
1888         deleteGraphicObject(pobjUID);
1889         return (char *)NULL;
1890     }
1891
1892     setGraphicObjectProperty(pobjUID, __GO_ARROW_SIZE__, &arsize, jni_double, 1);
1893
1894     /* Type 0 corresponds to a SEGS object */
1895     if (type == 0)
1896     {
1897         for (i = 0; i < numberArrows; i++)
1898         {
1899             arrowCoords[3 * i] = vx[2 * i];
1900             arrowCoords[3 * i + 1] = vy[2 * i];
1901
1902             if (vz != NULL)
1903             {
1904                 arrowCoords[3 * i + 2] = vz[2 * i];
1905             }
1906             else
1907             {
1908                 arrowCoords[3 * i + 2] = 0.0;
1909             }
1910         }
1911
1912         setGraphicObjectProperty(pobjUID, __GO_BASE__, arrowCoords, jni_double_vector, 3 * numberArrows);
1913
1914         for (i = 0; i < numberArrows; i++)
1915         {
1916             arrowCoords[3 * i] = vx[2 * i + 1];
1917             arrowCoords[3 * i + 1] = vy[2 * i + 1];
1918
1919             if (vz != NULL)
1920             {
1921                 arrowCoords[3 * i + 2] = vz[2 * i + 1];
1922             }
1923             else
1924             {
1925                 arrowCoords[3 * i + 2] = 0.0;
1926             }
1927         }
1928
1929         setGraphicObjectProperty(pobjUID, __GO_DIRECTION__, arrowCoords, jni_double_vector, 3 * numberArrows);
1930
1931         if (flag == 1)
1932         {
1933             /* Style is an array of numberArrows elements */
1934             setGraphicObjectProperty(pobjUID, __GO_SEGS_COLORS__, style, jni_int_vector, numberArrows);
1935         }
1936         else
1937         {
1938             /* Style is a scalar */
1939             setGraphicObjectProperty(pobjUID, __GO_SEGS_COLORS__, style, jni_int_vector, 1);
1940         }
1941
1942     }
1943     else
1944     {
1945         /*
1946          * Type 1 corresponds to a CHAMP object
1947          * so building comes from champg
1948          */
1949         setGraphicObjectProperty(pobjUID, __GO_BASE_X__, vx, jni_double_vector, Nbr1);
1950         setGraphicObjectProperty(pobjUID, __GO_BASE_Y__, vy, jni_double_vector, Nbr2);
1951
1952         /*
1953          * Foreground color
1954          * It has no apparent effect in Scilab 5.3.X and is therefore
1955          * commented out for now.
1956          */
1957 #if 0
1958         tmp = (int *)getGraphicObjectProperty(pparentsubwinUID, __GO_LINE_COLOR__, jni_int);
1959         foreground = *tmp;
1960         setGraphicObjectProperty(pobjUID, __GO_LINE_COLOR__, &foreground, jni_int, 1);
1961 #endif
1962
1963         for (i = 0; i < numberArrows; i++)
1964         {
1965             arrowCoords[3 * i] = vfx[i];
1966             arrowCoords[3 * i + 1] = vfy[i];
1967             arrowCoords[3 * i + 2] = 0.0;
1968         }
1969
1970         setGraphicObjectProperty(pobjUID, __GO_DIRECTION__, arrowCoords, jni_double_vector, 3 * numberArrows);
1971
1972         /* typeofchamp corresponds to COLORED (0: false, 1: true) */
1973         setGraphicObjectProperty(pobjUID, __GO_COLORED__, &typeofchamp, jni_bool, 1);
1974     }
1975
1976     /* Required to initialize the default contour properties */
1977     setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
1978
1979     /* Initializes the default Contour values */
1980     cloneGraphicContext(pparentsubwinUID, pobjUID);
1981
1982 //    if ( sciAddNewHandle(pobj) == -1 )
1983 //    {
1984 //        deleteGraphicObject(pobj->UID);
1985 //        FREE(arrowCoords);
1986 //        FREE(pobj);
1987 //        return (sciPointObj *) NULL;
1988 //    }
1989
1990     setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
1991
1992     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
1993
1994     FREE(arrowCoords);
1995
1996     return pobjUID;
1997 }
1998
1999 /**sciConstructCompound
2000  * constructs a Compound of entities
2001  * do only a association with a parent and a handle reservation !
2002  * check for valid handle can be done using CheckForCompound
2003  */
2004 char *ConstructCompound(long *handelsvalue, int number) /* Conflicting types with definition */
2005 {
2006     char *compoundUID = NULL;
2007     char *parentAxesUID = NULL;
2008     char *firstMovedObjectUID = NULL;
2009
2010     int i = 0;
2011     int parentVisible = 0;
2012     int *piParentVisible = &parentVisible;
2013
2014     compoundUID = createGraphicObject(__GO_COMPOUND__);
2015
2016     /* Add the Compound's handle */
2017 //  if (sciAddNewHandle(compound) == -1)
2018 //  {
2019 //    deleteGraphicObject(compound->UID);
2020 //    FREE(compound);
2021 //    return NULL;
2022 //  }
2023
2024     /* The Compound's parent Axes is considered to be the Compound's first child's own parent */
2025     firstMovedObjectUID = getObjectFromHandle((long)handelsvalue[0]);
2026     getGraphicObjectProperty(firstMovedObjectUID, __GO_PARENT__, jni_string, &parentAxesUID);
2027
2028     /* Set the parent-child relationship between the Compound and each aggregated object */
2029     for (i = 0; i < number; i++)
2030     {
2031         char *movedObjectUID = getObjectFromHandle((long)handelsvalue[i]);
2032
2033         setGraphicObjectRelationship(compoundUID, movedObjectUID);
2034     }
2035
2036     /* Sets the parent-child relationship for the Compound */
2037     setGraphicObjectRelationship(parentAxesUID, compoundUID);
2038
2039     /* Deactivated */
2040 #if 0
2041     ppCompound->callback = (char *)NULL;
2042     ppCompound->callbacklen = 0;
2043 #endif
2044
2045     /*
2046      * To be checked: difference between sciGetParentSubwin and directly getting
2047      * the Compound's parent's visible property
2048      */
2049 #if 0
2050     ppCompound->visible = sciGetVisibility(sciGetParentSubwin(compound));
2051 #endif
2052
2053     getGraphicObjectProperty(parentAxesUID, __GO_VISIBLE__, jni_bool, &piParentVisible);
2054     setGraphicObjectProperty(compoundUID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
2055
2056     /*
2057      * Not implemented within the MVC yet
2058      * To be implemented
2059      */
2060 #if 0
2061     ppCompound->isselected = TRUE;
2062 #endif
2063
2064     return (char *)compoundUID;
2065 }
2066
2067 /**ConstructCompoundSeq
2068  * constructs a Compound of with the last n entities created in the current subwindow
2069  on entry the subwin children list is
2070  s1->s2->...->sn->sn+1->...->sN
2071  with sn the least recent of the last n entities created and s1 the most recent one
2072  (that is, the last entity created), and N the subwin's initial number of children
2073  on exit it is
2074  A->sn+1->sn+2->...->sN
2075  with A a Compound object whose children list is:
2076  s1->s2->...->sn-1->sn
2077 */
2078 char *ConstructCompoundSeq(int number)
2079 {
2080     char **children = NULL;
2081     char *parentFigure = NULL;
2082     int numberChildren = 0;
2083     int *piNumberChildren = &numberChildren;
2084     int i = 0;
2085     int visible = 0;
2086     int *piVisible = &visible;
2087
2088     char *pobjUID = NULL;
2089     char *psubwinUID = getCurrentSubWin();
2090
2091     /* Creates the Compound object A */
2092     pobjUID = createGraphicObject(__GO_COMPOUND__);
2093
2094     /* Add the Compound's handle */
2095 //    if (sciAddNewHandle(pobj) == -1)
2096 //    {
2097 //        deleteGraphicObject(pobj->UID);
2098 //        FREE(pobj);
2099 //        return NULL;
2100 //    }
2101
2102     getGraphicObjectProperty(psubwinUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&piNumberChildren);
2103
2104     getGraphicObjectProperty(psubwinUID, __GO_CHILDREN__, jni_string_vector, (void **)&children);
2105
2106     /*
2107      * Remove the last "number" created objects (located at the children list's head)
2108      * and add them to the compound in the same order
2109      */
2110     for (i = 0; i < number; i++)
2111     {
2112         /*
2113          * Set the parent-child relationship between the Compound and each aggregated object.
2114          * Children are added to the Compound from the least recent to the most recent, to
2115          * preserve their former ordering.
2116          */
2117         setGraphicObjectRelationship(pobjUID, children[number - i - 1]);
2118     }
2119
2120     /* Sets the parent-child relationship for the Compound */
2121     setGraphicObjectRelationship(psubwinUID, pobjUID);
2122
2123     /*
2124      * visibility is obtained from the parent Figure, whereas it is retrieved from the
2125      * parent Axes in ConstructCompound.
2126      * To be made consistent.
2127      */
2128     getGraphicObjectProperty(pobjUID, __GO_PARENT_FIGURE__, jni_string, &parentFigure);
2129     getGraphicObjectProperty(parentFigure, __GO_VISIBLE__, jni_bool, &piVisible);
2130
2131     setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
2132
2133     /* To be implemented */
2134 #if 0
2135     ppagr->isselected = TRUE;
2136 #endif
2137
2138     return (char *)pobjUID;
2139 }
2140
2141 /**ConstructLabel
2142  * This function creates the Label structure used for x,y,z labels and for the Title.
2143  * On the contrary to the other Construct functions, it clones the Axes model's relevant
2144  * label instead of creating a new Label object and performing property sets using
2145  * the values of the Axes model's label, which is done instead by the clone call.
2146  * @param  char *pparentsubwinUID: the parent Axes' identifier.
2147  * @param  char text[] : initial text string, unused.
2148  * @param  int type to get info. on the type of label.
2149  * @return  : char* identifier if ok , NULL if not.
2150  */
2151 char *ConstructLabel(char *pparentsubwinUID, char *text, int type)
2152 {
2153     char *labelProperties[] = { __GO_X_AXIS_LABEL__, __GO_Y_AXIS_LABEL__, __GO_Z_AXIS_LABEL__, __GO_TITLE__ };
2154     char *parentType = NULL;
2155     char *labelType = NULL;
2156     char *modelLabelUID = NULL;
2157     char *pobjUID = NULL;
2158     int autoPosition = 0;
2159     int *piAutoPosition = &autoPosition;
2160     double position[3] = { 1.0, 1.0, 1.0 };
2161
2162     getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &parentType);
2163
2164     if (strcmp(parentType, __GO_AXES__) != 0)
2165     {
2166         Scierror(999, _("The parent has to be a SUBWIN\n"));
2167         return (char *)NULL;
2168     }
2169
2170     if (type < 1 || type > 4)
2171     {
2172         return (char *)NULL;
2173     }
2174
2175     labelType = labelProperties[type - 1];
2176
2177     getGraphicObjectProperty(getAxesModel(), labelType, jni_string, &modelLabelUID);
2178
2179     /* Creates a new Label object with the same properties as the Axes model's corresponding label */
2180     pobjUID = cloneGraphicObject(modelLabelUID);
2181
2182     /* Position set to {1, 1, 1} as a default to take into account logarithmic coordinates */
2183     setGraphicObjectProperty(pobjUID, __GO_POSITION__, position, jni_double_vector, 3);
2184
2185     /* Auto position must be reset as setting the position has set it to false */
2186     getGraphicObjectProperty(modelLabelUID, __GO_AUTO_POSITION__, jni_bool, &piAutoPosition);
2187     setGraphicObjectProperty(pobjUID, __GO_AUTO_POSITION__, &autoPosition, jni_bool, 1);
2188
2189     /* Attach the cloned label to its parent Axes and set the latter as the label's parent */
2190     setGraphicObjectProperty(pparentsubwinUID, labelType, pobjUID, jni_string, 1);
2191     setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
2192
2193     return pobjUID;
2194 }