3f2e8a88bf0f4b5700b0d292952e1cbf5da4820c
[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 "CurrentObjectsManagement.h"
40 #include "ObjectSelection.h"
41 #include "BuildDrawingObserver.h"
42 #include "WindowList.h"
43 #include "localization.h"
44 #include "GraphicSynchronizerInterface.h"
45 #include "Interaction.h"
46 #include "ColorMapManagement.h"
47 #include "get_ticks_utils.h"
48 #include "HandleManagement.h"
49 #include "loadTextRenderingAPI.h"
50
51 #include "MALLOC.h" /* MALLOC */
52 #include "Scierror.h"
53
54 #include "createGraphicObject.h"
55 #include "deleteGraphicObject.h"
56 #include "returnType.h"
57 #include "getGraphicObjectProperty.h"
58 #include "setGraphicObjectProperty.h"
59 #include "graphicObjectProperties.h"
60 #include "callJoGLView.h"
61
62 /*-----------------------------------------------------------------------------*/
63
64 /**ConstructFigure
65  * This function creates the parents window (manager) and the elementaries structures
66  * The function is graphic thread safe.
67  * @param figureIndex if NULL then a default value is chosen, otherwise use the pointed integer.
68  */
69 /************ 18/01/2002 ***********/
70 sciPointObj * ConstructFigure(sciPointObj * pparent, int * figureIndex)
71 {
72     sciPointObj *pClone = sciCloneObj(getFigureModel());
73     setGraphicObjectProperty(pClone->UID, __GO_ID__, figureIndex, jni_int, 1);
74     addNewFigureToList(pClone);
75     return pClone;
76
77 #ifdef __OLD_IMPLEMENTATION__
78   sciPointObj *pobj = (sciPointObj *) NULL;
79   int x[2];
80   sciPointObj * pfiguremdl = getFigureModel() ;
81   sciFigure   * ppFigure = NULL ;
82   sciFigure   * ppModel  = pFIGURE_FEATURE(pfiguremdl) ;
83
84   /* memory allocation for the new Figure   affectation du type allocation de la structure */
85
86   if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
87     {
88       return NULL;
89     }
90   sciSetEntityType (pobj, SCI_FIGURE);
91   if ((pobj->pfeatures = MALLOC ((sizeof (sciFigure)))) == NULL)
92     {
93       FREE(pobj);
94       return (sciPointObj *) NULL;
95     }
96
97         /* Create the default relationShip */
98         createDefaultRelationShip(pobj);
99
100   /* add a number in the HandelTable  reallocation de la table + 1 puis affectation de l'indice    */
101
102   ppFigure = pFIGURE_FEATURE(pobj) ;
103
104   /* No synchronization is needed here because nobody knows about the figure */
105   /* until we add it to the lists */
106
107   /* Don't call standard build operation since it add the figure to the handle list */
108
109   sciInitVisibility( pobj, TRUE ) ;
110
111         /* Clone user data from parent */
112   initUserData(pobj);
113         cloneUserData(pfiguremdl, pobj);
114
115
116   pobj->pObservers = DoublyLinkedList_new() ;
117   createDrawingObserver( pobj ) ;
118
119
120   pobj->pDrawer = NULL ;
121
122
123   /* initialisation de context et mode graphique par defaut (figure model)*/
124   if (sciInitGraphicContext (pobj) == -1)
125     {
126       FREE(pobj->pfeatures);
127       FREE(pobj);
128       return (sciPointObj *) NULL;
129     }
130   if (sciInitGraphicMode (pobj) == -1)
131     {
132       FREE(pobj->pfeatures);
133       FREE(pobj);
134       return (sciPointObj *) NULL;
135     }
136
137   /* F.Leray 08.04.04 */
138   if (sciInitFontContext (pobj) == -1)
139     {
140       FREE(pobj->pfeatures);
141       FREE(pobj);
142       return (sciPointObj *) NULL;
143     }
144   if (figureIndex != NULL)
145   {
146     sciInitNum(pobj, *figureIndex);
147   }
148   else
149   {
150     /* Set default figure index */
151     sciInitNum(pobj, getUnusedFigureIndex());
152   }
153
154   sciInitName(pobj, sciGetName(pfiguremdl));
155   sciInitResize(pobj,sciGetResize(pfiguremdl));
156
157   ppFigure->isselected = ppModel->isselected;
158   ppFigure->rotstyle = ppModel->rotstyle;
159   ppFigure->visible = ppModel->visible;
160   sciInitImmediateDrawingMode(pobj, sciGetImmediateDrawingMode(pfiguremdl));
161
162   ppFigure->numsubwinselected = ppModel->numsubwinselected;
163   ppFigure->pixmapMode = ppModel->pixmapMode ;
164   ppFigure->allredraw = ppModel->allredraw;
165   ppFigure->pModelData = NULL;
166
167   ppFigure->eventHandler = NULL ;
168   sciInitEventHandler( pobj, sciGetEventHandler( pfiguremdl ) ) ;
169   sciInitIsEventHandlerEnable( pobj, sciGetIsEventHandlerEnable( pfiguremdl ) ) ;
170
171   sciInitWindowDim(pobj, sciGetWindowWidth(pfiguremdl), sciGetWindowHeight(pfiguremdl) ) ;
172   /* Set axes_size after to be sure to have correct values */
173   if (sciInitDimension(pobj, sciGetWidth(pfiguremdl), sciGetHeight(pfiguremdl)) != RESIZE_SUCCESS)
174   {
175     FREE(pobj->pfeatures);
176     FREE(pobj);
177     return (sciPointObj *) NULL;
178   }
179
180   sciGetScreenPosition(pfiguremdl, &x[0], &x[1]) ;
181         if (x[0] != -1 || x[1] != -1)
182         {
183                 /* If default position is [-1,-1], then let the OS choose the window position. */
184                 sciInitScreenPosition( pobj, x[0], x[1] );
185         }
186
187         sciInitInfoMessage( pobj, ppModel->pModelData->infoMessage ) ;
188
189   ppFigure->tag = NULL;
190
191   sciInitPixmapMode(pobj, sciGetPixmapMode(pfiguremdl));
192
193         sciInitAntialiasingQuality(pobj, sciGetAntialiasingQuality(pfiguremdl));
194
195   /* Colormap */
196   sciInitNumColors(pobj, 0);
197   sciSetDefaultColorMap(pobj);
198
199   /* for java */
200   sciInitBackground(pobj, sciGetBackground(pfiguremdl));
201
202   /* Add the figure in the list of created figures */
203   /* Here we need to synchronize */
204   startGraphicDataWriting();
205   /* add the handle in the handle list */
206   if ( sciAddNewHandle(pobj) == -1 )
207   {
208     FREE(pobj->pfeatures);
209     FREE(pobj);
210     return NULL ;
211   }
212   addNewFigureToList(pobj);
213   endGraphicDataWriting();
214
215   // At least, should be only this call.
216   pobj->UID = createGraphicObject("figure");
217   setGraphicObjectProperty(pobj->UID, "Name", "MVC Name !!!", jni_string, 1);
218
219   setGraphicObjectProperty(pobj->UID, "InfoMessage", "MVC info message", jni_string, 1);
220
221   setGraphicObjectProperty(pobj->UID, "EventHandlerName", "MVC event handler", jni_string, 1);
222
223   /*
224    * Default colormap, temporary code
225    * the following code has been copied from the sciSetDefaultColorMap function
226    */
227   {
228     int numDefaultColors =  sciGetNumColors(getFigureModel());
229
230     double* tempDefaultColorMap = MALLOC(3*numDefaultColors*sizeof(double));
231
232     if(tempDefaultColorMap == NULL)
233     {
234       sciprint(_("%s: No more memory.\n"),"ConstructFigure");
235       return NULL;
236     }
237
238     sciGetColormap(getFigureModel(), tempDefaultColorMap);
239
240     setGraphicObjectProperty(pobj->UID, "ColorMap", tempDefaultColorMap, jni_double_vector, 3*numDefaultColors);
241
242     FREE(tempDefaultColorMap);
243   }
244
245
246   sciInitNumColors(pobj, 0);
247   sciSetDefaultColorMap(pobj);
248
249   return pobj;
250 #endif
251 }
252
253
254
255
256
257
258
259 /**ConstructSubWin
260  * This function creates the Subwindow (the Axes) and the elementary structures.
261  * It has been adapted to the MVC: all the initialization operations are now performed
262  * within the Model. The update of color properties (foreground, background, etc.)
263  * according to the assigned parent Figure's colormap is not implemented yet.
264  * To be implemented.
265  */
266 sciPointObj *
267 ConstructSubWin(sciPointObj * pparentfigure)
268 {
269     /*
270      * These variables were used by the now commented out
271      * initialization code.
272      * To be deleted
273      */
274 #if 0
275     char logFlags[3];
276     int i;
277     char dir;
278     BOOL autoTicks[3];
279     sciSubWindow * ppsubwin = NULL;
280     sciSubWindow * ppaxesmdl = pSUBWIN_FEATURE (paxesmdl);
281 #endif
282
283     char* parentType;
284
285     sciPointObj *pClone = (sciPointObj *) NULL;
286     sciPointObj * paxesmdl = getAxesModel();
287
288     getGraphicObjectProperty(pparentfigure->UID, __GO_TYPE__, jni_string, &parentType);
289
290     if (strcmp(parentType, __GO_FIGURE__) != 0)
291     {
292         Scierror(999, _("The parent has to be a FIGURE\n"));
293         return (sciPointObj*) NULL;
294     }
295
296     pClone = sciCloneObj(paxesmdl);
297
298     if ( sciAddNewHandle(pClone) == -1 )
299     {
300         deleteGraphicObject(pClone->UID);
301         FREE(pClone);
302         return (sciPointObj*) NULL;
303     }
304
305     setGraphicObjectRelationship(pparentfigure->UID, pClone->UID);
306
307     return pClone;
308
309    /*
310     * The following operations are now performed within the Model
311     * when cloning the Axes from the Axes model.
312     * To be deleted
313     */
314 #if 0
315         if (sciGetEntityType (pparentfigure) == SCI_FIGURE)
316         {
317
318                 if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
319                         return NULL;
320                 sciSetEntityType (pobj, SCI_SUBWIN);
321                 if ((pobj->pfeatures = MALLOC ((sizeof (sciSubWindow)))) == NULL)
322                 {
323                         FREE(pobj);
324                         return (sciPointObj *) NULL;
325                 }
326
327                 startFigureDataWriting(pparentfigure);
328
329                 if ( sciStandardBuildOperations( pobj, pparentfigure ) == NULL )
330                 {
331                         FREE( pobj->pfeatures ) ;
332                         FREE( pobj ) ;
333                         endFigureDataWriting(pparentfigure);
334                         return NULL ;
335                 }
336
337                 ppsubwin =  pSUBWIN_FEATURE (pobj); /* debug */
338
339
340                 ppsubwin->callback = (char *)NULL;
341                 ppsubwin->callbacklen = 0;
342                 ppsubwin->callbackevent = 100;
343
344                 if (sciInitGraphicContext (pobj) == -1)
345                 {
346                         sciDelThisToItsParent (pobj, sciGetParent (pobj));
347                         sciDelHandle (pobj);
348                         FREE(pobj->pfeatures);
349                         FREE(pobj);
350                         endFigureDataWriting(pparentfigure);
351                         return (sciPointObj *) NULL;
352                 }
353                 if (sciInitGraphicMode (pobj) == -1)
354                 {
355                         sciDelThisToItsParent (pobj, sciGetParent (pobj));
356                         sciDelHandle (pobj);
357                         FREE(pobj->pfeatures);
358                         FREE(pobj);
359                         endFigureDataWriting(pparentfigure);
360                         return (sciPointObj *) NULL;
361                 }
362
363                 /* F.Leray 08.04.04 */
364                 if (sciInitFontContext (pobj) == -1)
365                 {
366                         sciDelThisToItsParent (pobj, sciGetParent (pobj));
367                         sciDelHandle (pobj);
368                         FREE(pobj->pfeatures);
369                         FREE(pobj);
370                         endFigureDataWriting(pparentfigure);
371                         return (sciPointObj *) NULL;
372                 }
373
374                 /* update colors so they will fit the colormap of parent figure and not model one*/
375                 sciRecursiveUpdateBaW(pobj, sciGetNumColors(getFigureModel()), sciGetNumColors(sciGetParentFigure(pobj)));
376
377                 sciGetLogFlags(paxesmdl, logFlags);
378                 sciInitLogFlags(pobj, logFlags);
379
380                 ppsubwin->axes.ticscolor  = ppaxesmdl->axes.ticscolor;
381                 ppsubwin->axes.subint[0]  = ppaxesmdl->axes.subint[0];
382                 ppsubwin->axes.subint[1]  = ppaxesmdl->axes.subint[1];
383                 ppsubwin->axes.subint[2]  = ppaxesmdl->axes.subint[2];
384
385                 dir= ppaxesmdl->axes.xdir;
386                 ppsubwin->axes.xdir = dir;
387                 dir= ppaxesmdl->axes.ydir;
388                 ppsubwin->axes.ydir = dir;
389
390                 ppsubwin->axes.rect  = ppaxesmdl->axes.rect;
391                 sciInitIsFilled(pobj, sciGetIsFilled(paxesmdl));
392                 for (i=0 ; i<7 ; i++)
393                 {
394                         ppsubwin->axes.limits[i]  = ppaxesmdl->axes.limits[i] ;
395                 }
396
397                 for (i=0 ; i<3 ; i++)
398                 {
399                         ppsubwin->grid[i]  = ppaxesmdl->grid[i] ;
400                 }
401
402                 ppsubwin->gridFront = ppaxesmdl->gridFront;
403
404                 ppsubwin->alpha  = ppaxesmdl->alpha;
405                 ppsubwin->theta  = ppaxesmdl->theta;
406                 ppsubwin->alpha_kp  = ppaxesmdl->alpha_kp;
407                 ppsubwin->theta_kp  = ppaxesmdl->theta_kp;
408                 ppsubwin->is3d  = ppaxesmdl->is3d;
409
410                 /* F.Leray 22.09.04 */
411
412                 ppsubwin->axes.u_xlabels = (char **) NULL; /* init. ci-apres */
413                 ppsubwin->axes.u_ylabels = (char **) NULL; /* init. ci-apres */
414                 ppsubwin->axes.u_zlabels = (char **) NULL; /* init. ci-apres */
415                 ppsubwin->axes.u_xgrads  = (double *)NULL;
416                 ppsubwin->axes.u_ygrads  = (double *)NULL;
417                 ppsubwin->axes.u_zgrads  = (double *)NULL;
418
419
420                 (ppsubwin->axes).axes_visible[0] = ppaxesmdl->axes.axes_visible[0];
421                 (ppsubwin->axes).axes_visible[1] = ppaxesmdl->axes.axes_visible[1];
422                 (ppsubwin->axes).axes_visible[2] = ppaxesmdl->axes.axes_visible[2];
423                 (ppsubwin->axes).reverse[0] = ppaxesmdl->axes.reverse[0];
424                 (ppsubwin->axes).reverse[1] = ppaxesmdl->axes.reverse[1];
425                 (ppsubwin->axes).reverse[2] = ppaxesmdl->axes.reverse[2];
426                 ppsubwin->flagNax = ppaxesmdl->flagNax;
427
428                 /* do not forget the nbsubtics ! */
429                 (ppsubwin->axes).nbsubtics[0] = ppaxesmdl->axes.nbsubtics[0];
430                 (ppsubwin->axes).nbsubtics[1] = ppaxesmdl->axes.nbsubtics[1];
431                 (ppsubwin->axes).nbsubtics[2] = ppaxesmdl->axes.nbsubtics[2];
432
433                 (ppsubwin->axes).nxgrads = ppaxesmdl->axes.nxgrads;
434                 (ppsubwin->axes).nygrads = ppaxesmdl->axes.nygrads;
435                 (ppsubwin->axes).nzgrads = ppaxesmdl->axes.nzgrads;
436
437                 for(i=0;i<(ppsubwin->axes).nxgrads;i++) ppsubwin->axes.xgrads[i] = ppaxesmdl->axes.xgrads[i];
438                 for(i=0;i<(ppsubwin->axes).nygrads;i++) ppsubwin->axes.ygrads[i] = ppaxesmdl->axes.ygrads[i];
439                 for(i=0;i<(ppsubwin->axes).nzgrads;i++) ppsubwin->axes.zgrads[i] = ppaxesmdl->axes.zgrads[i];
440
441                 (ppsubwin->axes).u_nxgrads = ppaxesmdl->axes.u_nxgrads;
442                 (ppsubwin->axes).u_nygrads = ppaxesmdl->axes.u_nygrads;
443                 (ppsubwin->axes).u_nzgrads = ppaxesmdl->axes.u_nzgrads;
444                 (ppsubwin->axes).u_xgrads  = AllocUserGrads(ppsubwin->axes.u_xgrads,ppaxesmdl->axes.u_nxgrads);
445                 CopyUserGrads(ppaxesmdl->axes.u_xgrads,
446                         ppsubwin->axes.u_xgrads,
447                         ppsubwin->axes.u_nxgrads);
448                 (ppsubwin->axes).u_ygrads  = AllocUserGrads(ppsubwin->axes.u_ygrads,ppaxesmdl->axes.u_nygrads);
449                 CopyUserGrads(ppaxesmdl->axes.u_ygrads,
450                         ppsubwin->axes.u_ygrads,
451                         ppsubwin->axes.u_nygrads);
452                 (ppsubwin->axes).u_zgrads  = AllocUserGrads(ppsubwin->axes.u_zgrads,ppaxesmdl->axes.u_nzgrads);
453                 CopyUserGrads(ppaxesmdl->axes.u_zgrads,
454                         ppsubwin->axes.u_zgrads,
455                         ppsubwin->axes.u_nzgrads);
456                 (ppsubwin->axes).u_xlabels = AllocAndSetUserLabelsFromMdl(ppsubwin->axes.u_xlabels,
457                         ppaxesmdl->axes.u_xlabels,
458                         ppsubwin->axes.u_nxgrads);
459
460                 (ppsubwin->axes).u_ylabels = AllocAndSetUserLabelsFromMdl(ppsubwin->axes.u_ylabels,
461                         ppaxesmdl->axes.u_ylabels,
462                         ppsubwin->axes.u_nygrads);
463
464                 (ppsubwin->axes).u_zlabels = AllocAndSetUserLabelsFromMdl(ppsubwin->axes.u_zlabels,
465                         ppaxesmdl->axes.u_zlabels,
466                         ppsubwin->axes.u_nzgrads);
467
468                 sciGetAutoTicks(paxesmdl, autoTicks);
469                 sciInitAutoTicks(pobj, autoTicks[0], autoTicks[1], autoTicks[2]);
470                 /* end 22.09.04 */
471
472                 ppsubwin->axes.flag[0]= ppaxesmdl->axes.flag[0];
473                 ppsubwin->axes.flag[1]= ppaxesmdl->axes.flag[1];
474                 ppsubwin->axes.flag[2]= ppaxesmdl->axes.flag[2];
475                 sciInitHiddenAxisColor(pobj, sciGetHiddenAxisColor(paxesmdl));
476                 ppsubwin->project[0]= ppaxesmdl->project[0];
477                 ppsubwin->project[1]= ppaxesmdl->project[1];
478                 ppsubwin->project[2]= ppaxesmdl->project[2];
479                 sciInitHiddenColor(pobj, sciGetHiddenColor(paxesmdl));
480                 ppsubwin->isoview= ppaxesmdl->isoview;
481                 ppsubwin->WRect[0]   = ppaxesmdl->WRect[0];
482                 ppsubwin->WRect[1]   = ppaxesmdl->WRect[1];
483                 ppsubwin->WRect[2]   = ppaxesmdl->WRect[2];
484                 ppsubwin->WRect[3]   = ppaxesmdl->WRect[3];
485
486                 ppsubwin->ARect[0]   = ppaxesmdl->ARect[0];
487                 ppsubwin->ARect[1]   = ppaxesmdl->ARect[1];
488                 ppsubwin->ARect[2]   = ppaxesmdl->ARect[2];
489                 ppsubwin->ARect[3]   = ppaxesmdl->ARect[3];
490
491                 ppsubwin->FRect[0]   = ppaxesmdl->FRect[0];
492                 ppsubwin->FRect[1]   = ppaxesmdl->FRect[1] ;
493                 ppsubwin->FRect[2]   = ppaxesmdl->FRect[2];
494                 ppsubwin->FRect[3]   = ppaxesmdl->FRect[3];
495                 ppsubwin->FRect[4]   = ppaxesmdl->FRect[4] ;
496                 ppsubwin->FRect[5]   = ppaxesmdl->FRect[5];
497
498                 ppsubwin->visible = ppaxesmdl->visible;
499
500                 ppsubwin->clip_region_set = 0 ;
501                 sciInitIsClipping( pobj, sciGetIsClipping(paxesmdl) ) ;
502                 sciSetClipping(   pobj, sciGetClipping(  paxesmdl) ) ;
503
504                 ppsubwin->cube_scaling = ppaxesmdl->cube_scaling;
505
506                 ppsubwin->SRect[0]  =  ppaxesmdl->SRect[0];
507                 ppsubwin->SRect[1]  =  ppaxesmdl->SRect[1];
508                 ppsubwin->SRect[2]  =  ppaxesmdl->SRect[2];
509                 ppsubwin->SRect[3]  =  ppaxesmdl->SRect[3];
510                 ppsubwin->SRect[4]  =  ppaxesmdl->SRect[4];
511                 ppsubwin->SRect[5]  =  ppaxesmdl->SRect[5];
512
513                 ppsubwin->tight_limits = ppaxesmdl->tight_limits;
514                 ppsubwin->FirstPlot = ppaxesmdl->FirstPlot;
515
516                 sciInitUseNurbs(pobj, sciGetUseNurbs(paxesmdl));
517
518                 /* clone user data from model */
519                 cloneUserData(paxesmdl, pobj);
520
521                 if (sciInitSelectedSubWin(pobj) < 0 )
522                 {
523                         endFigureDataWriting(pparentfigure);
524                         return (sciPointObj *)NULL ;
525                 }
526
527                 /* Construction des labels: x,y,z et Title */
528
529                 if ((ppsubwin->mon_title =  ConstructLabel (pobj, "",1)) == NULL){
530                         sciDelThisToItsParent (pobj, sciGetParent (pobj)); /* pobj type = scisubwindow*/
531                         sciDelHandle (pobj);
532                         FREE(pobj->pfeatures);
533                         FREE(pobj);
534                         endFigureDataWriting(pparentfigure);
535                         return (sciPointObj *) NULL;
536                 }
537
538                 sciSetStrings( ppsubwin->mon_title,
539                         sciGetText( pSUBWIN_FEATURE(paxesmdl)->mon_title) ) ;
540
541
542                 /*------------------------------------*/
543                 if ((ppsubwin->mon_x_label =  ConstructLabel (pobj, "",2)) == NULL){
544                         DestroyLabel(ppsubwin->mon_title);
545                         sciDelThisToItsParent (pobj, sciGetParent (pobj));
546                         sciDelHandle (pobj);
547                         FREE(pobj->pfeatures);
548                         FREE(pobj);
549                         endFigureDataWriting(pparentfigure);
550                         return (sciPointObj *) NULL;
551                 }
552
553                 sciSetStrings( ppsubwin->mon_x_label,
554                         sciGetText(pSUBWIN_FEATURE(paxesmdl)->mon_x_label) ) ;
555
556
557                 /*------------------------------------*/
558                 if ((ppsubwin->mon_y_label =  ConstructLabel (pobj, "",3)) == NULL){
559                         DestroyLabel(ppsubwin->mon_title);
560                         DestroyLabel(ppsubwin->mon_x_label);
561                         sciDelThisToItsParent (pobj, sciGetParent (pobj));
562                         sciDelHandle (pobj);
563                         FREE(pobj->pfeatures);
564                         FREE(pobj);
565                         endFigureDataWriting(pparentfigure);
566                         return (sciPointObj *) NULL;
567                 }
568                 sciSetStrings( ppsubwin->mon_y_label,
569                         sciGetText( pSUBWIN_FEATURE(paxesmdl)->mon_y_label) ) ;
570
571                 /*------------------------------------*/
572                 if ((ppsubwin->mon_z_label =  ConstructLabel (pobj, "",4)) == NULL){
573                         DestroyLabel(ppsubwin->mon_title);
574                         DestroyLabel(ppsubwin->mon_x_label);
575                         DestroyLabel(ppsubwin->mon_y_label);
576                         sciDelThisToItsParent (pobj, sciGetParent (pobj));
577                         sciDelHandle (pobj);
578                         FREE(pobj->pfeatures);
579                         FREE(pobj);
580                         endFigureDataWriting(pparentfigure);
581                         return (sciPointObj *) NULL;
582                 }
583                 sciSetStrings( ppsubwin->mon_z_label,
584                         sciGetText(pSUBWIN_FEATURE(paxesmdl)->mon_z_label)  ) ;
585
586                 /* labels auto_position modes */
587                 pLABEL_FEATURE(ppsubwin->mon_x_label)->auto_position =
588                         pLABEL_FEATURE(ppaxesmdl->mon_x_label)->auto_position;
589
590                 pLABEL_FEATURE(ppsubwin->mon_y_label)->auto_position =
591                         pLABEL_FEATURE(ppaxesmdl->mon_y_label)->auto_position;
592
593                 pLABEL_FEATURE(ppsubwin->mon_z_label)->auto_position =
594                         pLABEL_FEATURE(ppaxesmdl->mon_z_label)->auto_position;
595
596                 pLABEL_FEATURE(ppsubwin->mon_title)->auto_position =
597                         pLABEL_FEATURE(ppaxesmdl->mon_title)->auto_position;
598
599                 /* labels auto_rotation modes */
600                 pLABEL_FEATURE(ppsubwin->mon_x_label)->auto_rotation =
601                         pLABEL_FEATURE(ppaxesmdl->mon_x_label)->auto_rotation;
602
603                 pLABEL_FEATURE(ppsubwin->mon_y_label)->auto_rotation =
604                         pLABEL_FEATURE(ppaxesmdl->mon_y_label)->auto_rotation;
605
606                 pLABEL_FEATURE(ppsubwin->mon_z_label)->auto_rotation =
607                         pLABEL_FEATURE(ppaxesmdl->mon_z_label)->auto_rotation;
608
609                 pLABEL_FEATURE(ppsubwin->mon_title)->auto_rotation =
610                         pLABEL_FEATURE(ppaxesmdl->mon_title)->auto_rotation;
611
612                 /*
613                  * Deactivated for now since the cloneGraphicContext function now
614                  * takes two char* (source MVC Identifier, destination MVC Identifier) as arguments.
615                  * To be implemented.
616                  */
617 #if 0
618                 cloneGraphicContext( ppaxesmdl->mon_x_label, ppsubwin->mon_x_label );
619                 cloneGraphicContext( ppaxesmdl->mon_y_label, ppsubwin->mon_y_label );
620                 cloneGraphicContext( ppaxesmdl->mon_z_label, ppsubwin->mon_z_label );
621                 cloneGraphicContext( ppaxesmdl->mon_title  , ppsubwin->mon_title   );
622 #endif
623
624                 endFigureDataWriting(pparentfigure);
625
626                 return (sciPointObj *)pobj;
627
628         }
629         else
630         {
631                 Scierror(999, _("The parent has to be a FIGURE\n"));
632                 return NULL;
633         }
634 #endif
635 }
636
637
638
639 /**
640  * Creates a new text object. However the object is not added in the handle list.
641  * Its graphic and font contexts are initialized.
642  * This function is to be used with objects including a text object.
643  */
644 sciPointObj * allocateText( sciPointObj       * pparentsubwin,
645                             char             ** text         ,
646                             int                 nbRow        ,
647                             int                 nbCol        ,
648                             double              x            ,
649                             double              y            ,
650                             BOOL                autoSize     ,
651                             double              userSize[2]  ,
652                             BOOL                centerPos    ,
653                             int               * foreground   ,
654                             int               * background   ,
655                             BOOL                isboxed      ,
656                             BOOL                isline       ,
657                             BOOL                isfilled     ,
658                             sciTextAlignment    align         )
659 {
660     sciPointObj * pObj = NULL;
661     int textDimensions[2];
662     int visible = 0;
663     int* piVisible = &visible;
664     int clipRegionSet;
665     int clipState = 0;
666     int* piClipState = &clipState;
667
668     double* clipRegion;
669     double position[3];
670     double setUserSize[2];
671
672     if ( ( pObj = MALLOC( sizeof(sciPointObj) ) ) == NULL )
673     {
674         return NULL;
675     }
676
677     pObj->UID = (char*) createGraphicObject(__GO_TEXT__);
678
679
680     /* Required to initialize the default contour properties */
681     setGraphicObjectProperty(pObj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
682
683     /* To be implemented */
684 #if 0
685     ppText->callback = (char *)NULL;
686     ppText->callbacklen = 0;
687     ppText->callbackevent = 100;
688     ppText->visible = sciGetVisibility( pparentsubwin );
689 #endif
690
691     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
692     setGraphicObjectProperty(pObj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
693
694     /* Clipping: to be checked for consistency */
695     clipRegionSet = 0;
696     setGraphicObjectProperty(pObj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
697
698     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
699     setGraphicObjectProperty(pObj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
700
701     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
702     setGraphicObjectProperty(pObj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
703
704     /* Check if we should load LaTex / MathML Java libraries */
705     loadTextRenderingAPI(text, nbRow, nbCol);
706
707     /* Allocates the String array */
708     textDimensions[0] = nbRow;
709     textDimensions[1] = nbCol;
710
711     setGraphicObjectProperty(pObj->UID, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
712
713     setGraphicObjectProperty(pObj->UID, __GO_TEXT_STRINGS__, text, jni_string_vector, nbRow*nbCol);
714
715     position[0] = x;
716     position[1] = y;
717     position[2] = 0.0;
718
719     setGraphicObjectProperty(pObj->UID, __GO_POSITION__, position, jni_double_vector, 3);
720
721     /*
722      * Possibly useless.
723      * To be deleted
724      */
725 #if 0
726     ppText->is3d = TRUE;
727 #endif
728
729   /*
730    * This was used by the previous renderer to return the Text
731    * object's bounding box, but has no present equivalent within the MVC.
732    * To be implemented when needed
733    */
734 #if 0
735   /* initialize to a not too weird value */
736   for (i = 0; i < 4; i++)
737   {
738     ppText->corners[i][0] = ppText->x;
739     ppText->corners[i][1] = ppText->y;
740     ppText->corners[i][2] = ppText->z;
741   }
742 #endif
743
744     setGraphicObjectProperty(pObj->UID, __GO_TEXT_BOX_MODE__, &centerPos, jni_int, 1);
745     setGraphicObjectProperty(pObj->UID, __GO_AUTO_DIMENSIONING__, &autoSize, jni_bool, 1);
746
747     /* userSize must be specified if the size is given by the user */
748     /* or the user specified a rectangle */
749     if (!autoSize || centerPos)
750     {
751         setUserSize[0] = userSize[0];
752         setUserSize[1] = userSize[1];
753     }
754     else
755     {
756         setUserSize[0] = 0.0;
757         setUserSize[1] = 0.0;
758     }
759
760     setGraphicObjectProperty(pObj->UID, __GO_TEXT_BOX__, setUserSize, jni_double_vector, 2);
761
762     /* Required to get the correct MVC value from the sciTextAlignment enum */
763     align = align - 1;
764
765     /* Set alignment to left if its value is incorrect */
766     if (align < 0 || align > 2)
767     {
768         align = 0;
769     }
770
771     setGraphicObjectProperty(pObj->UID, __GO_ALIGNMENT__, &align, jni_int, 1);
772
773     if ( sciInitGraphicContext( pObj ) == -1)
774     {
775         deleteGraphicObject(pObj->UID);
776         FREE(pObj);
777         return NULL;
778     }
779
780     if ( sciInitFontContext( pObj ) == -1 )
781     {
782         deleteGraphicObject(pObj->UID);
783         FREE(pObj);
784         return NULL;
785     }
786
787     setGraphicObjectProperty(pObj->UID, __GO_BOX__, &isboxed, jni_bool, 1);
788     setGraphicObjectProperty(pObj->UID, __GO_LINE_MODE__, &isline, jni_bool, 1);
789     setGraphicObjectProperty(pObj->UID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
790
791     if ( foreground != NULL )
792     {
793         setGraphicObjectProperty(pObj->UID, __GO_LINE_COLOR__, foreground, jni_int, 1);
794     }
795
796     if ( background != NULL )
797     {
798         setGraphicObjectProperty(pObj->UID, __GO_BACKGROUND__, foreground, jni_int, 1);
799     }
800
801     /* Parent reset to the null object */
802     setGraphicObjectProperty(pObj->UID, __GO_PARENT__, "", jni_string, 1);
803
804     return pObj;
805 }
806
807 /**ConstructText
808  * This function creates the parents window (manager) and the elementaries structures
809  * @param  sciPointObj *pparentsubwin :
810  * @param  char * text[] : intial text matrix string.
811  * @param  int nbCol : the number column of the text
812  * @param  int nbRow : the number of row of the text
813  * @return  : pointer sciPointObj if ok , NULL if not
814  */
815 sciPointObj *
816 ConstructText (sciPointObj * pparentsubwin, char ** text, int nbRow, int nbCol, double x,
817                double y, BOOL autoSize, double userSize[2], BOOL centerPos, int *foreground, int *background,
818                BOOL isboxed, BOOL isline, BOOL isfilled, sciTextAlignment align )
819 {
820     char* parentType;
821     sciPointObj* pobj;
822
823     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &parentType);
824
825     if (strcmp(parentType, __GO_AXES__) != 0)
826     {
827         Scierror(999, _("The parent has to be a SUBWIN\n"));
828         return (sciPointObj*) NULL;
829     }
830
831     pobj = allocateText( pparentsubwin, text, nbRow, nbCol, x, y,
832         autoSize, userSize, centerPos, foreground, background,
833         isboxed, isline, isfilled, align );
834
835     if ( pobj == NULL )
836     {
837         /* In this particular case, object deletion has already occured in allocateText */
838         return NULL;
839     }
840
841     if (sciAddNewHandle (pobj) == -1)
842     {
843         deleteGraphicObject(pobj->UID);
844         FREE(pobj);
845         return NULL;
846     }
847
848     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
849
850     return pobj;
851 }
852
853
854 /**constructLegend
855  * This function creates  Legend structure
856  */
857 sciPointObj *
858 ConstructLegend (sciPointObj * pparentsubwin, char **text, long long tabofhandles[], int nblegends)
859 {
860     sciPointObj * pobj = (sciPointObj *) NULL;
861
862     /* To be deleted */
863 #if 0
864     sciLegend   * ppLegend;
865 #endif
866
867     int i;
868     int iLegendPresent = 0;
869     int* piLegendPresent = &iLegendPresent;
870     int iVisible;
871     int* piVisible = &iVisible;
872     int* tmp;
873     int textDimensions[2];
874     int fillMode;
875     int legendLocation;
876
877     int clipRegionSet;
878     int clipState;
879
880     double* clipRegion;
881     double position[2];
882
883     char** lineIDS;
884     char* parentType;
885
886     /* Check beforehand whether a Legend object is already present */
887     getGraphicObjectProperty(pparentsubwin->UID, __GO_HAS_LEGEND_CHILD__, jni_bool, &piLegendPresent);
888
889     if (iLegendPresent)
890     {
891         /*
892          * Object deletion not implemented yet.
893          * To be implemented
894          */
895 #if 0
896         DestroyLegend();
897 #endif
898     }
899
900     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &parentType);
901
902     if (strcmp(parentType, __GO_AXES__) != 0)
903     {
904         Scierror(999, _("The parent has to be a SUBWIN\n"));
905         return (sciPointObj*) NULL;
906     }
907
908     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
909     {
910         return (sciPointObj*) NULL;
911     }
912
913     pobj->UID = (char*) createGraphicObject(__GO_LEGEND__);
914
915     /* Required to initialize the default contour and font properties */
916     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
917
918     /* To be implemented */
919 #if 0
920     ppLegend->text.callback = (char *)NULL;
921     ppLegend->text.callbacklen = 0;
922     ppLegend->text.callbackevent = 100;
923 #endif
924
925     /* To be implemented, probably useless */
926 #if 0
927     ppLegend->text.isboxed = FALSE;
928 #endif
929
930
931     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
932
933     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &iVisible, jni_bool, 1);
934
935     lineIDS = (char**) MALLOC(nblegends*sizeof(char*));
936
937     if (lineIDS == NULL)
938     {
939         Scierror(999, _("%s: No more memory.\n"),"ConstructLegend");
940         return (sciPointObj*) NULL;
941     }
942
943     textDimensions[0] = nblegends;
944     textDimensions[1] = 1;
945
946     setGraphicObjectProperty(pobj->UID, __GO_TEXT_ARRAY_DIMENSIONS__, textDimensions, jni_int_vector, 2);
947     setGraphicObjectProperty(pobj->UID, __GO_TEXT_STRINGS__, text, jni_string_vector, nblegends);
948
949     for (i = 0; i < nblegends; i++)
950     {
951         sciPointObj* tmpObj;
952
953         tmpObj =  sciGetPointerFromHandle(tabofhandles[i]);
954
955         /*
956          * Links are ordered from most recent to least recent,
957          * as their referred-to Polylines in the latter's parent Compound object.
958          */
959         lineIDS[nblegends-i-1] = tmpObj->UID;
960     }
961
962     setGraphicObjectProperty(pobj->UID, __GO_LINKS__, lineIDS, jni_string_vector, nblegends);
963
964     FREE(lineIDS);
965
966
967     position[0] = 0.0;
968     position[1] = 0.0;
969     setGraphicObjectProperty(pobj->UID, __GO_POSITION__, position, jni_double_vector, 2);
970
971
972     /* 9: LOWER_CAPTION */
973     legendLocation = 9;
974     setGraphicObjectProperty(pobj->UID, __GO_LEGEND_LOCATION__, &legendLocation, jni_int, 1);
975
976     /* To be implemented */
977 #if 0
978     ppLegend->isselected = TRUE;
979 #endif
980
981     /* Clipping: to be checked for consistency */
982     clipRegionSet = 0;
983     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
984
985     /* 0: OFF */
986     clipState = 0;
987     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
988
989     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
990     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
991
992
993     /* NEW :  used to draw the line and marks of the curve F.Leray 21.01.05 */
994     if (sciInitGraphicContext (pobj) == -1)
995     {
996         deleteGraphicObject(pobj->UID);
997         FREE(pobj);
998         return (sciPointObj*) NULL;
999     }
1000
1001     if (sciInitFontContext (pobj) == -1)
1002     {
1003         deleteGraphicObject(pobj->UID);
1004         FREE(pobj);
1005         return (sciPointObj*) NULL;
1006     }
1007
1008     fillMode = TRUE;
1009     setGraphicObjectProperty(pobj->UID, __GO_FILL_MODE__, &fillMode, jni_bool, 1);
1010
1011     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
1012
1013     if (sciAddNewHandle(pobj) == -1)
1014     {
1015         deleteGraphicObject(pobj->UID);
1016         FREE(pobj);
1017         return NULL;
1018     }
1019
1020     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
1021
1022     return pobj;
1023 }
1024 /*---------------------------------------------------------------------------------*/
1025 /**
1026  * Create a polyline but does not add it to Scilab hierarchy
1027  */
1028 sciPointObj * allocatePolyline(sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
1029                                int closed, int n1,int plot, int *foreground, int *background,
1030                                int *mark_style, int *mark_foreground, int *mark_background,
1031                                BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
1032 {
1033   sciPointObj * pobj = NULL;
1034   int i = 0;
1035   BOOL result;
1036   char* type;
1037   char* polylineID;
1038   double barWidth;
1039   double arrowSizeFactor;
1040   double* clipRegion;
1041   double* dataVector;
1042   int clipState = 0;
1043   int *piClipState = &clipState;
1044   int lineClosed;
1045   int numElementsArray[2];
1046   int polylineStyle;
1047   int visible = 0;
1048   int* piVisible = &visible;
1049   int zCoordinatesSet;
1050   int* tmp;
1051   int clipRegionSet = 0;
1052   int *piClipRegionSet = &clipRegionSet;
1053
1054
1055   getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &type);
1056
1057   if (strcmp(type, __GO_AXES__) != 0)
1058   {
1059     Scierror(999, _("The parent has to be a SUBWIN\n"));
1060     return (sciPointObj *) NULL;
1061   }
1062
1063   if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
1064   {
1065     return NULL;
1066   }
1067
1068   pobj->UID = (char*) createGraphicObject(__GO_POLYLINE__);
1069
1070   polylineID = (char*) createDataObject(pobj->UID, __GO_POLYLINE__);
1071
1072   if (polylineID == NULL)
1073   {
1074     deleteGraphicObject(pobj->UID);
1075     FREE(pobj);
1076     return (sciPointObj*) NULL;
1077   }
1078
1079   /* To be deleted */
1080 #if 0
1081   /* Create the default relationShip */
1082   createDefaultRelationShip(pobj);
1083 #endif
1084
1085   /* To be deleted */
1086 #if 0
1087   sciSetParent( pobj, pparentsubwin );
1088 #endif
1089
1090   /*
1091    * Sets the polyline's parent in order to initialize the former's Contoured properties
1092    * with the latter's values (sciInitGraphicContext call below)
1093    */
1094   setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
1095
1096
1097   barWidth = 0.0;
1098   setGraphicObjectProperty(pobj->UID, __GO_BAR_WIDTH__, &barWidth, jni_double, 1);
1099
1100   /* To be implemented */
1101 #if 0
1102   pPOLYLINE_FEATURE (pobj)->callback = (char *)NULL;
1103   pPOLYLINE_FEATURE (pobj)->callbacklen = 0;
1104   pPOLYLINE_FEATURE (pobj)->callbackevent = 100;
1105 #endif
1106
1107   getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
1108
1109   setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
1110
1111
1112   /* To be deleted, see the MVC corresponding calls below */
1113 #if 0
1114   pPOLYLINE_FEATURE (pobj)->clip_region_set = 0;
1115   sciInitIsClipping( pobj, sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)) ) ;
1116   sciSetClipping(pobj,sciGetClipping(sciGetParentSubwin(pobj)));
1117 #endif
1118
1119   /* Clip state and region */
1120   /* To be checked for consistency */
1121
1122   getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1123   setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1124
1125   getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1126   setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1127
1128   getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
1129   setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1130
1131
1132   arrowSizeFactor = 1.0;
1133   setGraphicObjectProperty(pobj->UID, __GO_ARROW_SIZE_FACTOR__, &arrowSizeFactor, jni_double, 1);
1134
1135   /* To be implemented */
1136 #if 0
1137   pPOLYLINE_FEATURE (pobj)->isselected = TRUE;
1138 #endif
1139
1140
1141   /*
1142    * First element: number of gons (always 1 for a Polyline)
1143    * Second one: number of vertices composing the Polyline
1144    */
1145   numElementsArray[0] = 1;
1146   numElementsArray[1] = n1;
1147
1148   /* Data */
1149   if ( n1 != 0 )
1150   {
1151     /*
1152      * Sets the number of elements (vertices composing the polyline) and allocates the coordinates array
1153      * The FALSE value is used to identify a failed memory allocation for now.
1154      */
1155     result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
1156
1157     if (result == FALSE)
1158     {
1159         deleteGraphicObject(pobj->UID);
1160         deleteDataObject(pobj->UID);
1161         FREE(pobj);
1162         return (sciPointObj *) NULL;
1163     }
1164
1165     dataVector = MALLOC(3*n1*sizeof(double));
1166
1167     if (dataVector == NULL)
1168     {
1169         deleteGraphicObject(pobj->UID);
1170         deleteDataObject(pobj->UID);
1171         FREE(pobj);
1172         return (sciPointObj *) NULL;
1173     }
1174
1175     if ((pvecx != (double *)NULL)&&(pvecy != (double *)NULL))
1176     {
1177         for (i = 0; i < n1; i++)
1178         {
1179             dataVector[i] = pvecx[i];
1180             dataVector[n1+i] = pvecy[i];
1181         }
1182     }
1183     else
1184     {
1185         for (i = 0; i < n1; i++)
1186         {
1187             dataVector[i] = 0.0;
1188             dataVector[n1+i] = 0.0;
1189         }
1190     }
1191
1192     /**DJ.Abdemouche 2003**/
1193     if (pvecz == NULL)
1194     {
1195         for (i = 0; i < n1; i++)
1196         {
1197             dataVector[2*n1+i] = 0.0;
1198         }
1199
1200         zCoordinatesSet = 0;
1201     }
1202     else
1203     {
1204         for (i = 0; i < n1; i++)
1205         {
1206             dataVector[2*n1+i] = pvecz[i];
1207         }
1208
1209         zCoordinatesSet = 1;
1210     }
1211
1212     /*
1213      * We could probably do without the dataVector copy by individually setting
1214      * x, y or z coordinates, and initializing coordinates to 0 during allocation
1215      * to ensure consistency
1216      */
1217     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_COORDINATES__, dataVector, jni_double, n1);
1218
1219     FREE(dataVector);
1220
1221     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_double, n1);
1222   }
1223   else
1224   {
1225       /* 0 points */
1226       result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
1227
1228       if (result == FALSE)
1229       {
1230           deleteGraphicObject(pobj->UID);
1231           deleteDataObject(pobj->UID);
1232           FREE(pobj);
1233           return (sciPointObj *) NULL;
1234       }
1235   }
1236
1237   if (closed > 0)
1238   {
1239       lineClosed = 1;
1240   }
1241   else
1242   {
1243       lineClosed = 0;
1244   }
1245
1246   setGraphicObjectProperty(pobj->UID, __GO_CLOSED__, &lineClosed, jni_bool, 1);
1247   setGraphicObjectProperty(pobj->UID, __GO_POLYLINE_STYLE__, &plot, jni_int, 1);
1248
1249   /*
1250    * Initializes the contour properties (background, foreground, etc)
1251    * to the default values (those of the parent Axes).
1252    */
1253
1254   sciInitGraphicContext(pobj);
1255
1256   /* To be deleted */
1257 #if 0
1258   if (sciInitGraphicContext (pobj) == -1)
1259   {
1260     FREE(pPOLYLINE_FEATURE (pobj)->pvy);
1261     FREE(pPOLYLINE_FEATURE (pobj)->pvx);
1262     FREE(pPOLYLINE_FEATURE(pobj));
1263     FREE(pobj);
1264     return (sciPointObj *) NULL;
1265   }
1266 #endif
1267
1268   /* colors and marks setting */
1269   setGraphicObjectProperty(pobj->UID, __GO_MARK_MODE__, &ismark, jni_bool, 1);
1270   setGraphicObjectProperty(pobj->UID, __GO_LINE_MODE__, &isline, jni_bool, 1);
1271   setGraphicObjectProperty(pobj->UID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
1272
1273   /* shading interpolation vector and mode */
1274   setGraphicObjectProperty(pobj->UID, __GO_INTERP_COLOR_MODE__, &isinterpshaded, jni_bool, 1);
1275
1276   if(foreground != NULL)
1277   {
1278       setGraphicObjectProperty(pobj->UID, __GO_LINE_COLOR__, foreground, jni_int, 1);
1279
1280       /* To be fully implemented within the MVC framework since it performs color range checks */
1281 #if 0
1282       sciInitForeground(pobj,(*foreground));
1283 #endif
1284   }
1285
1286   if(background != NULL){
1287       if(isinterpshaded == TRUE)
1288       { /* 3 or 4 values to store */
1289
1290           setGraphicObjectProperty(pobj->UID, __GO_INTERP_COLOR_VECTOR__, background, jni_int_vector, n1);
1291
1292           /* To be deleted */
1293 #if 0
1294           sciSetInterpVector(pobj,n1,background);
1295 #endif
1296       }
1297       else
1298       {
1299           setGraphicObjectProperty(pobj->UID, __GO_BACKGROUND__, background, jni_int, 1);
1300
1301     /* To be fully implemented within the MVC framework since it performs color range checks */
1302 #if 0
1303           sciInitBackground(pobj,(*background));
1304 #endif
1305       }
1306   }
1307
1308   if(mark_style != NULL)
1309   {
1310       /* This does use the MVC */
1311       sciInitMarkStyle(pobj,(*mark_style));
1312   }
1313
1314   if(mark_foreground != NULL)
1315   {
1316     setGraphicObjectProperty(pobj->UID, __GO_MARK_FOREGROUND__, mark_foreground, jni_int, 1);
1317
1318     /* To be fully implemented within the MVC framework since it performs color range checks */
1319 #if 0
1320     sciInitMarkForeground(pobj,(*mark_foreground));
1321 #endif
1322   }
1323
1324   if(mark_background != NULL)
1325   {
1326     setGraphicObjectProperty(pobj->UID, __GO_MARK_BACKGROUND__, mark_background, jni_int, 1);
1327
1328     /* To be fully implemented within the MVC framework since it performs color range checks */
1329 #if 0
1330     sciInitMarkBackground(pobj,(*mark_background));
1331 #endif
1332   }
1333
1334   /* no sons for now */
1335   /* To be deleted */
1336 #if 0
1337   sciInitSelectedSons( pobj ) ;
1338
1339   sciGetRelationship(pobj)->psons        = NULL ;
1340   sciGetRelationship(pobj)->plastsons    = NULL ;
1341   sciGetRelationship(pobj)->pSelectedSon = NULL ;
1342 #endif
1343
1344   /* Parent reset to the null object */
1345   setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
1346
1347   visible = 1;
1348   setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
1349
1350   /*
1351    * Deactivated for now since not fully implemented yet by the MVC
1352    * To be implemented
1353    */
1354 #if 0
1355   initUserData(pobj);
1356 #endif
1357
1358   /*
1359    * To be deleted
1360    */
1361   pobj->pObservers = NULL;
1362
1363   pobj->pDrawer = NULL;
1364
1365   return pobj;
1366
1367 }
1368 /*---------------------------------------------------------------------------------*/
1369 /**ConstructPolyline
1370  * This function creates  Polyline 2d structure
1371  */
1372 sciPointObj *
1373 ConstructPolyline (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
1374                    int closed, int n1,int plot, int *foreground, int *background,
1375                    int *mark_style, int *mark_foreground, int *mark_background,
1376                    BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
1377 {
1378   sciPointObj * pobj = allocatePolyline(pparentsubwin, pvecx, pvecy, pvecz, closed, n1, plot,
1379                                         foreground, background, mark_style, mark_foreground, mark_background,
1380                                         isline, isfilled, ismark, isinterpshaded);
1381
1382   if (pobj == NULL)
1383   {
1384     return NULL;
1385   }
1386
1387   /* allocatePolyline created a "fake" relationship, destroy it */
1388   /*
1389    * Deactivated since the sciPolyline struct is not used anymore
1390    * and sciStandardBuildOperations uses the obsolete C hierarchical
1391    * relationships.
1392    * The operations still relevant are performed below
1393    * (sciStandardBuildOperations should be updated as to include them).
1394    */
1395 #if 0
1396   FREE(pobj->relationShip);
1397
1398   if (sciStandardBuildOperations(pobj, pparentsubwin) == NULL)
1399   {
1400     FREE(pobj->pfeatures);
1401     FREE(pobj);
1402     return NULL;
1403   }
1404 #endif
1405
1406
1407   if (sciAddNewHandle(pobj) == -1)
1408   {
1409     deleteGraphicObject(pobj->UID);
1410     deleteDataObject(pobj->UID);
1411     FREE(pobj);
1412     return NULL;
1413   }
1414
1415   /*
1416    * Sets the Axes as the polyline's parent and adds the polyline to
1417    * its parent's list of children.
1418    */
1419   setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
1420
1421   return pobj;
1422
1423 }
1424
1425
1426
1427 /**ConstructArc
1428  * This function creates an Arc structure
1429  */
1430 sciPointObj *
1431 ConstructArc (sciPointObj * pparentsubwin, double x, double y,
1432               double height, double width, double alphabegin, double alphaend,
1433               int *foreground, int *background, BOOL isfilled, BOOL isline)
1434 {
1435     char* type;
1436     double upperLeftPoint[3];
1437     double* clipRegion;
1438     int* tmp;
1439     int visible = 0;
1440     int *piVisible = &visible;
1441     int arcDrawingMethod = 0;
1442     int *piArcDrawingMethod = &arcDrawingMethod;
1443     int clipRegionSet = 0;
1444     int *piClipRegionSet = &clipRegionSet;
1445     int clipState = 0;
1446     int *piClipState = &clipState;
1447     sciPointObj * pobj  = (sciPointObj *) NULL;
1448
1449     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &type);
1450
1451     if (strcmp(type, __GO_AXES__) != 0)
1452     {
1453         Scierror(999, _("The parent has to be a SUBWIN\n"));
1454         return (sciPointObj *) NULL;
1455     }
1456
1457     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
1458     {
1459         return (sciPointObj *) NULL;
1460     }
1461
1462     pobj->UID = (char*) createGraphicObject(__GO_ARC__);
1463
1464     /*
1465      * Sets the arc's parent in order to initialize the former's Contoured properties
1466      * with the latter's values (sciInitGraphicContext call below)
1467      */
1468     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
1469
1470     /* To be implemented */
1471 #if 0
1472     ppArc->callback = (char *)NULL;
1473     ppArc->callbacklen = 0;
1474     ppArc->callbackevent = 100;
1475 #endif
1476
1477     upperLeftPoint[0] = x;
1478     upperLeftPoint[1] = y;
1479     upperLeftPoint[2] = 0.0;
1480
1481     setGraphicObjectProperty(pobj->UID, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
1482
1483     setGraphicObjectProperty(pobj->UID, __GO_HEIGHT__, &height, jni_double, 1);
1484     setGraphicObjectProperty(pobj->UID, __GO_WIDTH__, &width, jni_double, 1);
1485
1486     setGraphicObjectProperty(pobj->UID, __GO_START_ANGLE__, &alphabegin, jni_double, 1);
1487     setGraphicObjectProperty(pobj->UID, __GO_END_ANGLE__, &alphaend, jni_double, 1);
1488
1489     /* To be implemented */
1490 #if 0
1491     ppArc->isselected = TRUE;
1492 #endif
1493
1494     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
1495
1496     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
1497
1498     getGraphicObjectProperty(pparentsubwin->UID, __GO_ARC_DRAWING_METHOD__, jni_int, &piArcDrawingMethod);
1499
1500     setGraphicObjectProperty(pobj->UID, __GO_ARC_DRAWING_METHOD__, &arcDrawingMethod, jni_int, 1);
1501
1502     /* To be checked for consistency */
1503 #if 0
1504       ppArc->clip_region_set = 0;
1505       /*ppArc->isclip = sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)); */
1506       sciInitIsClipping( pobj, sciGetIsClipping(pparentsubwin) ) ;
1507       sciSetClipping(pobj,sciGetClipping(pparentsubwin));
1508       /*      pARC_FEATURE (pobj)->clip_region = (double *) NULL; */
1509 #endif
1510
1511     /*
1512      * Clip state and region
1513      * To be checked for consistency
1514      */
1515       getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1516       setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1517
1518       getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1519       setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1520
1521       getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
1522     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1523
1524
1525     if (sciInitGraphicContext (pobj) == -1)
1526     {
1527         deleteGraphicObject(pobj->UID);
1528         FREE(pobj);
1529         return (sciPointObj *) NULL;
1530     }
1531
1532     /* Contour settings */
1533     setGraphicObjectProperty(pobj->UID, __GO_LINE_MODE__, &isline, jni_bool, 1);
1534     setGraphicObjectProperty(pobj->UID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
1535
1536     if(foreground != NULL)
1537     {
1538         setGraphicObjectProperty(pobj->UID, __GO_LINE_COLOR__, foreground, jni_int, 1);
1539     }
1540
1541     if(background != NULL)
1542     {
1543         setGraphicObjectProperty(pobj->UID, __GO_BACKGROUND__, background, jni_int, 1);
1544     }
1545
1546     /* Parent reset to the null object */
1547     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
1548
1549     if (sciAddNewHandle(pobj) == -1)
1550     {
1551         deleteGraphicObject(pobj->UID);
1552         FREE(pobj);
1553         return NULL;
1554     }
1555
1556     /*
1557      * Sets the Axes as the arc's parent and adds the arc to
1558      * its parent's list of children.
1559      */
1560     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
1561
1562     return pobj;
1563 }
1564
1565
1566
1567 /**ConstructRectangle
1568  * This function creates Rectangle structure and only this to destroy all sons use DelGraphicsSon
1569  */
1570 sciPointObj *
1571 ConstructRectangle (sciPointObj * pparentsubwin, double x, double y,
1572                     double height, double width,  int *foreground, int *background,
1573                     int isfilled, int isline)
1574 {
1575     char* type;
1576     double upperLeftPoint[3];
1577     double* clipRegion;
1578     int visible = 0;
1579     int *piVisible = &visible;
1580     int* tmp;
1581     int clipRegionSet = 0;
1582     int *piClipRegionSet = &clipRegionSet;
1583     int clipState = 0;
1584     int *piClipState = &clipState;
1585
1586     sciPointObj *pobj = (sciPointObj *) NULL;
1587
1588     if ( height < 0.0 || width < 0.0 )
1589     {
1590         Scierror(999,_("Width and height must be positive.\n"));
1591         return NULL;
1592     }
1593
1594     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &type);
1595
1596     if (strcmp(type, __GO_AXES__) != 0)
1597     {
1598         Scierror(999, _("The parent has to be a SUBWIN\n"));
1599         return (sciPointObj *) NULL;
1600     }
1601
1602     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
1603     {
1604         return (sciPointObj *) NULL;
1605     }
1606
1607     pobj->UID = (char*) createGraphicObject(__GO_RECTANGLE__);
1608
1609     /*
1610      * Sets the rectangle's parent in order to initialize the former's Contoured properties
1611      * with the latter's values (sciInitGraphicContext call below)
1612      */
1613     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
1614
1615       /* To be implemented */
1616 #if 0
1617       pRECTANGLE_FEATURE (pobj)->callback = (char *)NULL;
1618       pRECTANGLE_FEATURE (pobj)->callbacklen = 0;
1619       pRECTANGLE_FEATURE (pobj)->callbackevent = 100;
1620 #endif
1621
1622     upperLeftPoint[0] = x;
1623     upperLeftPoint[1] = y;
1624     upperLeftPoint[2] = 0.0;
1625
1626     setGraphicObjectProperty(pobj->UID, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
1627
1628     setGraphicObjectProperty(pobj->UID, __GO_HEIGHT__, &height, jni_double, 1);
1629     setGraphicObjectProperty(pobj->UID, __GO_WIDTH__, &width, jni_double, 1);
1630
1631       /* To be implemented */
1632 #if 0
1633     pRECTANGLE_FEATURE (pobj)->isselected = TRUE;
1634 #endif
1635
1636     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
1637     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
1638
1639     /* Clipping: to be checked */
1640 #if 0
1641     pRECTANGLE_FEATURE (pobj)->clip_region_set = 0;
1642     sciInitIsClipping( pobj, sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)) ) ;
1643     sciSetClipping(pobj,sciGetClipping(sciGetParentSubwin(pobj)));
1644 #endif
1645
1646     /* Clip state and region */
1647     /* To be checked for consistency */
1648
1649     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1650     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1651
1652     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1653     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1654
1655     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
1656     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1657
1658     /*
1659      * Initializes the contour properties (background, foreground, etc)
1660      * to the default values (those of the parent Axes).
1661      */
1662     if (sciInitGraphicContext (pobj) == -1)
1663     {
1664         deleteGraphicObject(pobj->UID);
1665         FREE(pobj);
1666         return (sciPointObj *) NULL;
1667     }
1668
1669     /* Contour settings */
1670     setGraphicObjectProperty(pobj->UID, __GO_LINE_MODE__, &isline, jni_bool, 1);
1671     setGraphicObjectProperty(pobj->UID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
1672
1673     if(foreground != NULL)
1674     {
1675         setGraphicObjectProperty(pobj->UID, __GO_LINE_COLOR__, foreground, jni_int, 1);
1676     }
1677
1678     if(background != NULL)
1679     {
1680         setGraphicObjectProperty(pobj->UID, __GO_BACKGROUND__, background, jni_int, 1);
1681     }
1682
1683     /* Parent reset to the null object */
1684     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
1685
1686     if (sciAddNewHandle(pobj) == -1)
1687     {
1688         deleteGraphicObject(pobj->UID);
1689         FREE(pobj);
1690         return NULL;
1691     }
1692
1693     /*
1694      * Sets the Axes as the rectangle's parent and adds the rectangle to
1695      * its parent's list of children.
1696      */
1697     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
1698
1699     return pobj;
1700 }
1701
1702
1703
1704 /**ConstructSurface
1705  * This function creates Surface Structure
1706  */
1707 sciPointObj *
1708 ConstructSurface (sciPointObj * pparentsubwin, sciTypeOf3D typeof3d,
1709                   double * pvecx, double * pvecy, double * pvecz,double *zcol,
1710                   int izcol, int dimzx, int dimzy,
1711                   int *flag, double *ebox,int flagcolor,
1712                   int *isfac, int *m1, int *n1, int *m2,
1713                   int *n2, int *m3, int *n3, int *m3n, int *n3n)
1714 {
1715     sciPointObj *pobj = (sciPointObj *) NULL;
1716     /*debug F.Leray*/
1717     /* To be deleted */
1718 #if 0
1719     sciSurface *psurf;
1720 #endif
1721
1722     char* parentType;
1723     char* surfaceID;
1724     char* surfaceTypes[2] = {__GO_PLOT3D__, __GO_FAC3D__};
1725
1726     double* clipRegion;
1727
1728     int i=0, j=0;
1729     int nx,ny,nz,nc,izc=izcol;
1730     int result;
1731     int clipRegionSet = 0;
1732     int *piClipRegionSet = &clipRegionSet;
1733     int clipState = 0;
1734     int *piClipState = &clipState;
1735     int visible = 0;
1736     int *piVisible = &visible;
1737     int cdataMapping;
1738     int hiddenColor = 0;
1739     int *piHiddenColor = &hiddenColor;
1740     int surfaceMode;
1741     int* tmp;
1742
1743     /* To be modified: the MVC does not allow Plot3d objects with color data yet */
1744     if (typeof3d == SCI_PLOT3D)
1745     {
1746         nx=dimzx;
1747         ny=dimzy;
1748         nz=dimzx*dimzy;
1749         if (flagcolor == 2)
1750         {
1751             /* one color per facet: nc = dimzx * dimzy */
1752             nc=nz;
1753         }
1754         else if (flagcolor == 3)
1755         {
1756             /*
1757              * one color per edge: nc = 4* dimzx * dimzy ??????
1758              * 3 or 4 vertices are needed: I think we take 4 to have enough allocated memory
1759              */
1760             nc=nz*4;
1761          }
1762         /* made by Djalel : comes from the genfac3d case */
1763         else
1764         {
1765             nc=0;
1766         }
1767     }
1768     /* DJ.A 2003 */
1769     else
1770     { /* case SCI_FAC3D */
1771         nx=dimzx*dimzy;
1772         ny=dimzx*dimzy;
1773         nz=dimzx*dimzy;
1774         if (flagcolor == 2)
1775         {
1776             /* one color per facet: nc = dimzy */
1777             nc=dimzy;
1778         }
1779         else if (flagcolor == 3)
1780         {
1781             /* one color per edge: nc = dimzx * dimzy */
1782             nc=nz;
1783         }
1784         else
1785         {
1786             nc=0;
1787         }
1788     }
1789
1790     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &parentType);
1791
1792     /* test using sciGetEntityType replaced by a test on the type string */
1793     if (strcmp(parentType, __GO_AXES__) != 0)
1794     {
1795         Scierror(999, _("The parent has to be a SUBWIN\n"));
1796         return (sciPointObj *) NULL;
1797     }
1798
1799     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
1800     {
1801         return (sciPointObj *) NULL;
1802     }
1803
1804     /* To be implemented */
1805 #if 0
1806     psurf->callback = (char *)NULL;
1807     psurf->callbacklen = 0;
1808     psurf->callbackevent = 100;
1809 #endif
1810
1811     pobj->UID = (char*) createGraphicObject(surfaceTypes[*isfac]);
1812     surfaceID = (char*) createDataObject(pobj->UID, surfaceTypes[*isfac]);
1813
1814     /*Adding F.Leray 19.03.04*/
1815     /* Dimension of the color matrix, to be implemented (vector case) */
1816 #if 0
1817     psurf->m3n= *m3n;
1818     psurf->n3n= *n3n;
1819 #endif
1820
1821     /* Clip state and region */
1822     /* To be checked for consistency */
1823
1824     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
1825     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
1826
1827     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
1828     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
1829
1830     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
1831     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
1832
1833     /* Visibility */
1834     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
1835
1836     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
1837
1838     setGraphicObjectProperty(pobj->UID, __GO_COLOR_FLAG__, &flagcolor, jni_int, 1);
1839
1840     /* Direct mode enabled as default */
1841     cdataMapping = 1;
1842
1843     /* Only for Fac3D */
1844     setGraphicObjectProperty(pobj->UID, __GO_DATA_MAPPING__, &cdataMapping, jni_int, 1);
1845
1846     setGraphicObjectProperty(pobj->UID, __GO_COLOR_MODE__, &flag[0], jni_int, 1);
1847
1848     /* Plot3d case */
1849     if (!*isfac)
1850     {
1851         int gridSize[4];
1852
1853         gridSize[0] = *m1;
1854         gridSize[1] = *n1;
1855         gridSize[2] = *m2;
1856         gridSize[3] = *n2;
1857
1858         /* Allocates the coordinates arrays */
1859         result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
1860     }
1861     /* Fac3d case */
1862     else
1863     {
1864         int numElementsArray[3];
1865
1866         /*
1867          * First element: number of n-gons
1868          * Second element: number of vertices per n-gon
1869          * Third element: number of input colors
1870          */
1871         numElementsArray[0] = dimzy;
1872         numElementsArray[1] = dimzx;
1873         numElementsArray[2] = nc;
1874
1875         /* Allocates the coordinates and color arrays */
1876         result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 3);
1877     }
1878
1879     if (result == 0)
1880     {
1881         deleteGraphicObject(pobj->UID);
1882         deleteDataObject(pobj->UID);
1883         FREE(pobj);
1884         return (sciPointObj*) NULL;
1885     }
1886
1887     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, nx);
1888     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, ny);
1889     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Z__, pvecz, jni_double_vector, nz);
1890
1891     /* Add the color matrix dimensions as a property ? */
1892     if (nc > 0)
1893     {
1894         setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_COLORS__, zcol, jni_double_vector, nc);
1895     }
1896
1897     /*-------END Replaced by: --------*/
1898
1899     /* To be implemented */
1900 #if 0
1901     psurf->isselected = TRUE;
1902 #endif
1903
1904     /* The flag array is apparently now useless (flag[0] == COLOR_MODE, the two remaining ones are unused) */
1905 #if 0
1906     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)] */
1907     psurf->flag[1] = flag[1];
1908     psurf->flag[2] = flag[2];
1909 #endif
1910
1911     /* DJ.A 2003 */
1912     /* Apparently useless */
1913 #if 0
1914     psurf->ebox[0] = ebox[0];
1915     psurf->ebox[1] = ebox[1];
1916     psurf->ebox[2] = ebox[2];
1917     psurf->ebox[3] = ebox[3];
1918     psurf->ebox[4] = ebox[4];
1919     psurf->ebox[5] = ebox[5];
1920 #endif
1921
1922     getGraphicObjectProperty(pparentsubwin->UID, __GO_HIDDEN_COLOR__, jni_int, &piHiddenColor);
1923     setGraphicObjectProperty(pobj->UID, __GO_HIDDEN_COLOR__, &hiddenColor, jni_int, 1);
1924
1925     /*
1926      * surfaceMode set to "on", was previously done by InitGraphicContext, by setting
1927      * the graphic context's line_mode to on, which previously stood for the surface_mode.
1928      */
1929     surfaceMode = 1;
1930
1931     setGraphicObjectProperty(pobj->UID, __GO_SURFACE_MODE__, &surfaceMode, jni_bool, 1);
1932
1933
1934     /*
1935      * Adding a new handle and setting the parent-child relationship is now
1936      * done after data initialization in order to avoid additional
1937      * clean-up.
1938      */
1939     if (sciAddNewHandle(pobj) == -1)
1940     {
1941         deleteGraphicObject(pobj->UID);
1942         deleteDataObject(pobj->UID);
1943         FREE(pobj);
1944         return (sciPointObj*) NULL;
1945     }
1946
1947     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
1948
1949     if (sciInitGraphicContext (pobj) == -1)
1950     {
1951         setGraphicObjectRelationship("", pobj->UID);
1952         deleteGraphicObject(pobj->UID);
1953         deleteDataObject(pobj->UID);
1954         sciDelHandle(pobj);
1955
1956         FREE(pobj);
1957         return (sciPointObj *) NULL;
1958     }
1959
1960     return pobj;
1961 }
1962
1963 /********************** 14/05/2002 *****
1964  **ConstructGrayplot
1965  * This function is used to build Grayplot and Matplot objects.
1966  * It would probably be better to put the code related to Matplot objects
1967  * in a separate build function, as it would avoid having to perform several tests
1968  * on the type parameter. This is done so because Matplot objects were previously
1969  * internally represented by sciGrayplot structures.
1970  */
1971 sciPointObj *
1972 ConstructGrayplot (sciPointObj * pparentsubwin, double *pvecx, double *pvecy,
1973                    double *pvecz, int n1, int n2, int type)
1974 {
1975     sciPointObj *pobj = (sciPointObj *) NULL;
1976
1977     char* objectTypes[3] = {__GO_GRAYPLOT__, __GO_MATPLOT__, __GO_MATPLOT__};
1978
1979     char* typeParent;
1980     char* grayplotID;
1981     int result;
1982     int dataMapping;
1983     int gridSize[4];
1984
1985     int parentVisible = 0;
1986     int *piParentVisible = &parentVisible;
1987     double* clipRegion;
1988     int clipRegionSet = 0;
1989     int *piClipRegionSet = &clipRegionSet;
1990     int clipState = 0;
1991     int *piClipState = &clipState;
1992     int* tmp;
1993     int numElements;
1994
1995     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &typeParent);
1996
1997     if (strcmp(typeParent, __GO_AXES__) != 0)
1998     {
1999         Scierror(999, _("The parent has to be a SUBWIN\n"));
2000         return (sciPointObj *) NULL;
2001     }
2002
2003     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
2004     {
2005         return (sciPointObj *) NULL;
2006     }
2007
2008     pobj->UID = (char*) createGraphicObject(objectTypes[type]);
2009     grayplotID = (char*) createDataObject(pobj->UID, objectTypes[type]);
2010
2011     if (grayplotID == NULL)
2012     {
2013         deleteGraphicObject(pobj->UID);
2014         FREE(pobj);
2015         return (sciPointObj*) NULL;
2016     }
2017
2018     /* To be implemented */
2019 #if 0
2020     pGRAYPLOT_FEATURE (pobj)->callback = (char *)NULL;
2021     pGRAYPLOT_FEATURE (pobj)->callbacklen = 0;
2022     pGRAYPLOT_FEATURE (pobj)->callbackevent = 100;
2023
2024     pGRAYPLOT_FEATURE (pobj)->isselected = TRUE;
2025 #endif
2026
2027     /* 0: scaled; only used for Grayplot */
2028     if (type == 0)
2029     {
2030         dataMapping = 0;
2031         setGraphicObjectProperty(pobj->UID, __GO_DATA_MAPPING__, &dataMapping, jni_int, 1);
2032     }
2033
2034     /* The x and y vectors are column ones */
2035
2036     /*
2037      * For the Grayplot object, the number of rows and columns respectively
2038      * correspond to the grid's x and y dimensions whereas for Matplot objects,
2039      * they respectively correspond to the grid's y and x dimensions.
2040      */
2041     if (type == 0)
2042     {
2043         gridSize[0] = n1;
2044         gridSize[1] = 1;
2045         gridSize[2] = n2;
2046         gridSize[3] = 1;
2047     }
2048     else
2049     {
2050         gridSize[0] = n2;
2051         gridSize[1] = 1;
2052         gridSize[2] = n1;
2053         gridSize[3] = 1;
2054     }
2055
2056     /* Only for Matplot objects */
2057     if (type != 0)
2058     {
2059         if (type == 1)
2060         {
2061             setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_MATPLOT_BOUNDS__, NULL, jni_double_vector, 4);
2062         }
2063         else if (type == 2)
2064         {
2065             setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_MATPLOT_BOUNDS__, pvecx, jni_double_vector, 4);
2066         }
2067     }
2068
2069     /* Allocates the coordinates arrays */
2070     result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
2071
2072     if (result == 0)
2073     {
2074         deleteGraphicObject(pobj->UID);
2075         deleteDataObject(pobj->UID);
2076         FREE(pobj);
2077         return (sciPointObj*) NULL;
2078     }
2079
2080     /* Only for Grayplot objects, for Matplot objects, x and y coordinates are automatically computed */
2081     if (type == 0)
2082     {
2083         setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, n1);
2084         setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, n2);
2085     }
2086
2087     if (type == 0)
2088     {
2089         numElements = n1*n2;
2090     }
2091     else
2092     {
2093         numElements = (n1-1)*(n2-1);
2094     }
2095
2096     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Z__, pvecz, jni_double_vector, numElements);
2097
2098     /*
2099      * Adding a new handle and setting the parent-child relationship is now
2100      * done after data initialization in order to avoid additional
2101      * clean-up.
2102      */
2103     if (sciAddNewHandle(pobj) == -1)
2104     {
2105         deleteGraphicObject(pobj->UID);
2106         FREE(pobj);
2107         return (sciPointObj*) NULL;
2108     }
2109
2110     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
2111
2112
2113     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piParentVisible);
2114     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
2115
2116    /*
2117     * Clip state and region
2118     * To be checked for consistency
2119     */
2120     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
2121     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
2122
2123     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
2124     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
2125
2126     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
2127     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
2128
2129     if (sciInitGraphicContext (pobj) == -1)
2130     {
2131         setGraphicObjectRelationship("", pobj->UID);
2132         deleteGraphicObject(pobj->UID);
2133         deleteDataObject(pobj->UID);
2134         sciDelHandle(pobj);
2135
2136         FREE(pobj);
2137         return (sciPointObj *) NULL;
2138     }
2139
2140     return pobj;
2141 }
2142
2143
2144 /**ConstructAxes
2145  * This function creates an Axis object
2146  * To do: rename to ConstructAxis
2147  * @author Djalel ABDEMOUCHE
2148  * @see sciSetCurrentObj
2149  *
2150  */
2151 sciPointObj *
2152 ConstructAxes (sciPointObj * pparentsubwin, char dir, char tics, double *vx,
2153                int nx, double *vy, int ny,char **str, int subint, char *format,
2154                int fontsize, int textcolor, int ticscolor, char logscale, int seg, int nb_tics_labels)
2155 {
2156     char* parentType;
2157     sciPointObj *pobj = (sciPointObj *) NULL;
2158     int i;
2159     int clipRegionSet;
2160     int clipState;
2161     int ticksDirection;
2162     int ticksStyle;
2163     double* clipRegion;
2164     double doubleFontSize;
2165
2166     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &parentType);
2167
2168     if (strcmp(parentType, __GO_AXES__) != 0)
2169     {
2170         Scierror(999, _("The parent has to be a SUBWIN\n"));
2171         return (sciPointObj*) NULL;
2172     }
2173
2174     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
2175     {
2176         return (sciPointObj *) NULL;
2177     }
2178
2179     pobj->UID = (char*) createGraphicObject(__GO_AXIS__);
2180
2181     /* Required to initialize the default contour properties */
2182     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
2183
2184     /* To be implemented */
2185 #if 0
2186     pAXES_FEATURE (pobj)->callback = (char *)NULL;
2187     pAXES_FEATURE (pobj)->callbacklen = 0;
2188     pAXES_FEATURE (pobj)->callbackevent = 100;
2189     pAXES_FEATURE (pobj)->visible = sciGetVisibility(sciGetParentSubwin(pobj));
2190 #endif
2191
2192     /* Clipping: to be checked for consistency */
2193     clipRegionSet = 0;
2194     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
2195
2196     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
2197     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
2198
2199     /* 0: OFF */
2200     clipState = 0;
2201     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
2202
2203     /* The ticks style and direction MVC properties are Integers */
2204     if (dir == 'u')
2205     {
2206         ticksDirection = 0;
2207     }
2208     else if (dir == 'd')
2209     {
2210         ticksDirection = 1;
2211     }
2212     else if (dir == 'l')
2213     {
2214         ticksDirection = 2;
2215     }
2216     else if (dir == 'r')
2217     {
2218         ticksDirection = 3;
2219     }
2220     else
2221     {
2222         ticksDirection = 0;
2223     }
2224
2225     if (tics == 'v')
2226     {
2227         ticksStyle = 0;
2228     }
2229     else if (tics == 'r')
2230     {
2231         ticksStyle = 1;
2232     }
2233     else if (tics == 'i')
2234     {
2235         ticksStyle = 2;
2236     }
2237     else
2238     {
2239         ticksStyle = 0;
2240     }
2241
2242     setGraphicObjectProperty(pobj->UID, __GO_TICKS_DIRECTION__, &ticksDirection, jni_int, 1);
2243     setGraphicObjectProperty(pobj->UID, __GO_TICKS_STYLE__, &ticksStyle, jni_int, 1);
2244
2245     setGraphicObjectProperty(pobj->UID, __GO_X_TICKS_COORDS__, vx, jni_double_vector, nx);
2246     setGraphicObjectProperty(pobj->UID, __GO_Y_TICKS_COORDS__, vy, jni_double_vector, ny);
2247
2248     /*
2249      * Labels are computed automatically depending on the ticks coordinates.
2250      * The computation is performed by a C function which has been adapted
2251      * to the MVC (property get calls) and was previously done in the
2252      * tics labels property get C function.
2253      * It should be done (or called) directly in the Java part of the model
2254      * for the sake of efficiency.
2255      * To be modified
2256      */
2257     if (str == NULL)
2258     {
2259         char** matData;
2260         StringMatrix* tics_labels;
2261
2262         tics_labels = computeDefaultTicsLabels(pobj);
2263
2264         if (tics_labels == NULL)
2265         {
2266             deleteGraphicObject(pobj->UID);
2267             FREE(pobj);
2268             return (sciPointObj*) NULL;
2269         }
2270
2271         matData = getStrMatData(tics_labels);
2272
2273         /*
2274          * The labels vector size must be computed using the matrix's dimensions.
2275          * To be modified when the labels computation is moved to the Model.
2276          */
2277         setGraphicObjectProperty(pobj->UID, __GO_TICKS_LABELS__, matData, jni_string_vector, tics_labels->nbCol*tics_labels->nbRow);
2278
2279         deleteMatrix(tics_labels);
2280     }
2281     else
2282     {
2283         /*
2284          * Labels are set using the str argument; the previous code tested whether each element of the
2285          * str array was null and set the corresponding Axis' element to NULL, though there was no
2286          * apparent reason to do so. This is still checked, but now aborts building the Axis.
2287          */
2288
2289         if(nb_tics_labels == -1)
2290         {
2291             Scierror(999, _("Impossible case when building axis\n"));
2292             deleteGraphicObject(pobj->UID);
2293             FREE(pobj);
2294             return (sciPointObj*) NULL;
2295         }
2296
2297         for (i = 0; i < nb_tics_labels; i++)
2298         {
2299             if (str[i] == NULL)
2300             {
2301                 deleteGraphicObject(pobj->UID);
2302                 FREE(pobj);
2303                 return (sciPointObj*) NULL;
2304             }
2305         }
2306
2307         setGraphicObjectProperty(pobj->UID, __GO_TICKS_LABELS__, str, jni_string_vector, nb_tics_labels);
2308     }
2309
2310     setGraphicObjectProperty(pobj->UID, __GO_SUBTICKS__, &subint, jni_int, 1);
2311     setGraphicObjectProperty(pobj->UID, __GO_TICKS_SEGMENT__, &seg, jni_bool, 1);
2312
2313     if (format != NULL)
2314     {
2315         setGraphicObjectProperty(pobj->UID, __GO_FORMATN__, format, jni_string, 1);
2316     }
2317
2318     if (sciInitGraphicContext (pobj) == -1)
2319     {
2320         deleteGraphicObject(pobj->UID);
2321         FREE(pobj);
2322         return (sciPointObj*) NULL;
2323     }
2324
2325     if ( sciInitFontContext( pobj ) == -1 )
2326     {
2327         deleteGraphicObject(pobj->UID);
2328         FREE(pobj);
2329         return (sciPointObj*) NULL;
2330     }
2331
2332     /* Parent reset to the null object */
2333     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
2334
2335     if (sciAddNewHandle(pobj) == -1)
2336     {
2337         deleteGraphicObject(pobj->UID);
2338         deleteDataObject(pobj->UID);
2339         FREE(pobj);
2340         return (sciPointObj*) NULL;
2341     }
2342
2343     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
2344
2345     doubleFontSize = (double) fontsize;
2346
2347     setGraphicObjectProperty(pobj->UID, __GO_FONT_SIZE__, &doubleFontSize, jni_double, 1);
2348     setGraphicObjectProperty(pobj->UID, __GO_FONT_COLOR__, &textcolor, jni_int, 1);
2349     setGraphicObjectProperty(pobj->UID, __GO_TICKS_COLOR__, &ticscolor, jni_int, 1);
2350
2351     return pobj;
2352 }
2353
2354
2355 /********************** 21/05/2002 *****
2356  **ConstructFec
2357  * This function creates Fec
2358  * @author Djalel.ABDEMOUCHE
2359  * @see sciSetCurrentObj
2360  */
2361 sciPointObj *
2362 ConstructFec (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pnoeud,
2363               double *pfun, int Nnode, int Ntr, double *zminmax, int *colminmax,
2364               int *colout, BOOL with_mesh)
2365 {
2366     sciPointObj *pobj = (sciPointObj *) NULL;
2367     char* fecId = NULL;
2368     int result;
2369
2370     char* parentType;
2371     int parentVisible = 0;
2372     int *piParentVisible = &parentVisible;
2373
2374     int lineMode;
2375
2376     double* clipRegion;
2377     int clipRegionSet = 0;
2378     int *piClipRegionSet = &clipRegionSet;
2379     int clipState = 0;
2380     int *piClipState = &piClipState;
2381     int* tmp;
2382
2383     getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &parentType);
2384
2385     /* test using sciGetEntityType replaced by a test on the type string */
2386     if (strcmp(parentType, __GO_AXES__) != 0)
2387     {
2388         Scierror(999, _("The parent has to be a SUBWIN\n"));
2389         return (sciPointObj *) NULL;
2390     }
2391
2392     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
2393     {
2394         return (sciPointObj *) NULL;
2395     }
2396
2397     pobj->UID = createGraphicObject(__GO_FEC__);
2398     fecId = (char*) createDataObject(pobj->UID, __GO_FEC__);
2399
2400     if (fecId == NULL)
2401     {
2402         deleteGraphicObject(pobj->UID);
2403         FREE(pobj);
2404         return (sciPointObj*) NULL;
2405     }
2406
2407     /* To be implemented */
2408 #if 0
2409     pFEC_FEATURE (pobj)->callback = (char *)NULL;
2410     pFEC_FEATURE (pobj)->callbacklen = 0;
2411     pFEC_FEATURE (pobj)->callbackevent = 100;
2412
2413     pFEC_FEATURE (pobj)->isselected = TRUE;
2414 #endif
2415
2416     /* Allocates the coordinates array */
2417     result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_VERTICES__, &Nnode, jni_int, 1);
2418
2419     if (result == 0)
2420     {
2421         deleteGraphicObject(pobj->UID);
2422         deleteDataObject(pobj->UID);
2423         FREE(pobj);
2424         return (sciPointObj*) NULL;
2425     }
2426
2427     /* Allocates the triangle indices and values array */
2428     result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_INDICES__, &Ntr, jni_int, 1);
2429
2430     if (result == 0)
2431     {
2432         deleteGraphicObject(pobj->UID);
2433         deleteDataObject(pobj->UID);
2434         FREE(pobj);
2435         return (sciPointObj*) NULL;
2436     }
2437
2438     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, Nnode);
2439     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, Nnode);
2440
2441     /* Fec-specific property: triangle indices plus special values (triangle number and flag) */
2442     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_FEC_TRIANGLES__, pnoeud, jni_double_vector, Ntr);
2443
2444     /* Function values */
2445     setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_VALUES__, pfun, jni_double_vector, Nnode);
2446
2447     setGraphicObjectProperty(pobj->UID, __GO_Z_BOUNDS__, zminmax, jni_double_vector, 2);
2448     setGraphicObjectProperty(pobj->UID, __GO_COLOR_RANGE__, colminmax, jni_int_vector, 2);
2449     setGraphicObjectProperty(pobj->UID, __GO_OUTSIDE_COLOR__, colout, jni_int_vector, 2);
2450
2451     /*
2452      * Adding a new handle and setting the parent-child relationship is now
2453      * done after data initialization in order to avoid additional
2454      * clean-up.
2455      */
2456     if (sciAddNewHandle(pobj) == -1)
2457     {
2458         deleteGraphicObject(pobj->UID);
2459         deleteDataObject(pobj->UID);
2460         FREE(pobj);
2461         return (sciPointObj*) NULL;
2462     }
2463
2464     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
2465
2466 #if 0
2467     pFEC_FEATURE (pobj)->visible = sciGetVisibility(sciGetParentSubwin(pobj));
2468 #endif
2469
2470     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piParentVisible);
2471     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
2472
2473     /* Clipping: to be checked */
2474 #if 0
2475     sciInitIsClipping( pobj, sciGetIsClipping(pparentsubwin) ) ;
2476     sciSetClipping(pobj, sciGetClipping(pparentsubwin)) ;
2477 #endif
2478
2479    /*
2480     * Clip state and region
2481     * To be checked for consistency
2482     */
2483     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
2484     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
2485
2486     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
2487     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
2488
2489     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
2490     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
2491
2492     if (sciInitGraphicContext (pobj) == -1)
2493     {
2494         setGraphicObjectRelationship("", pobj->UID);
2495         deleteGraphicObject(pobj->UID);
2496         deleteDataObject(pobj->UID);
2497         sciDelHandle(pobj);
2498
2499         FREE(pobj);
2500         return (sciPointObj *) NULL;
2501     }
2502
2503     /* line mode is set using with_mesh */
2504     setGraphicObjectProperty(pobj->UID, __GO_LINE_MODE__, &with_mesh, jni_bool, 1);
2505
2506     return pobj;
2507 }
2508
2509
2510
2511 /**ConstructSegs
2512  * This function creates Segments
2513  * It is used to create and initialize the data of both the Champ and Segs MVC objects.
2514  * @author Djalel.ABDEMOUCHE
2515  * @version 0.1
2516  * @see sciSetCurrentObj
2517  */
2518 sciPointObj *
2519 ConstructSegs ( sciPointObj * pparentsubwin, int type,
2520                 double *vx, double *vy, double *vz,
2521                 int Nbr1,int Nbr2, int Nbr3,
2522                 double *vfx, double *vfy,
2523                 int flag, int *style, double arsize,
2524                 int colored, int typeofchamp)
2525 {
2526     sciPointObj *pobj = (sciPointObj *) NULL;
2527     /* To be deleted */
2528 #if 0
2529     sciSegs * ppSegs = (sciSegs *) NULL;
2530 #endif
2531     int visible = 0;
2532     int* piVisible = &visible;
2533     int clipRegionSet = 0;
2534     int *piClipRegionSet = &clipRegionSet;
2535     int clipState = 0;
2536     int* piClipState = &clipState;
2537     int numberArrows;
2538     int dimensions[2];
2539     int i;
2540     int foreground;
2541     int* tmp;
2542
2543     double* clipRegion;
2544     double* arrowCoords;
2545
2546     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
2547     {
2548         return (sciPointObj *) NULL;
2549     }
2550
2551     if (type == 0)
2552     {
2553         pobj->UID = createGraphicObject(__GO_SEGS__);
2554     }
2555     else if (type == 1)
2556     {
2557         pobj->UID = createGraphicObject(__GO_CHAMP__);
2558     }
2559     else
2560     {
2561         return (sciPointObj*) NULL;
2562     }
2563
2564     /* To be implemented */
2565 #if 0
2566     ppSegs->callback = (char *)NULL;
2567     ppSegs->callbacklen = 0;
2568     ppSegs->callbackevent = 100;
2569
2570     ppSegs->isselected = TRUE;
2571 #endif
2572
2573     getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
2574
2575     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
2576
2577     /* this must be done prior to the call of sciSetClipping to know */
2578     /* if the clip_state has been set */
2579
2580    /*
2581     * Clip state and region
2582     * To be checked for consistency
2583     */
2584     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
2585     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
2586
2587     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
2588     setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
2589
2590     getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
2591     setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
2592
2593
2594     if (type == 1)
2595     {
2596         numberArrows = Nbr1*Nbr2;
2597     }
2598     else
2599     {
2600         /* Segs: Nbr1/2 arrows, Nbr1 is the number of endpoints */
2601         numberArrows = Nbr1/2;
2602     }
2603
2604     /* Triggers the creation of the Arrow objects part of Champ or Segs */
2605     setGraphicObjectProperty(pobj->UID, __GO_NUMBER_ARROWS__, &numberArrows, jni_int, 1);
2606
2607     /* Champ property only */
2608     if (type == 1)
2609     {
2610         dimensions[0] = Nbr1;
2611         dimensions[1] = Nbr2;
2612
2613         setGraphicObjectProperty(pobj->UID, __GO_CHAMP_DIMENSIONS__, dimensions, jni_int_vector, 2);
2614     }
2615
2616     arrowCoords = (double*) MALLOC(3*numberArrows*sizeof(double));
2617
2618     if (arrowCoords == NULL)
2619     {
2620         deleteGraphicObject(pobj->UID);
2621         FREE(pobj);
2622         return (sciPointObj*) NULL;
2623     }
2624
2625     /* Type 0 corresponds to a SEGS object */
2626     if (type == 0)
2627     {
2628         for (i = 0; i < numberArrows; i++)
2629         {
2630             arrowCoords[3*i] = vx[2*i];
2631             arrowCoords[3*i+1] = vy[2*i];
2632
2633             if (vz != NULL)
2634             {
2635                 arrowCoords[3*i+2] = vz[2*i];
2636             }
2637             else
2638             {
2639                 arrowCoords[3*i+2] = 0.0;
2640             }
2641         }
2642
2643         setGraphicObjectProperty(pobj->UID, __GO_BASE__, arrowCoords, jni_double_vector, 3*numberArrows);
2644
2645         for (i = 0; i < numberArrows; i++)
2646         {
2647             arrowCoords[3*i] = vx[2*i+1];
2648             arrowCoords[3*i+1] = vy[2*i+1];
2649
2650             if (vz != NULL)
2651             {
2652                 arrowCoords[3*i+2] = vz[2*i+1];
2653             }
2654             else
2655             {
2656                 arrowCoords[3*i+2] = 0.0;
2657             }
2658         }
2659
2660         setGraphicObjectProperty(pobj->UID, __GO_DIRECTION__, arrowCoords, jni_double_vector, 3*numberArrows);
2661
2662         if (flag == 1)
2663         {
2664             /* Style is an array of numberArrows elements */
2665             setGraphicObjectProperty(pobj->UID, __GO_SEGS_COLORS__, style, jni_int_vector, numberArrows);
2666         }
2667         else
2668         {
2669             /* Style is a scalar */
2670             setGraphicObjectProperty(pobj->UID, __GO_SEGS_COLORS__, style, jni_int_vector, 1);
2671         }
2672
2673     }
2674     else
2675     {
2676         /*
2677          * Type 1 corresponds to a CHAMP object
2678          * so building comes from champg
2679          */
2680         setGraphicObjectProperty(pobj->UID, __GO_BASE_X__, vx, jni_double_vector, Nbr1);
2681         setGraphicObjectProperty(pobj->UID, __GO_BASE_Y__, vy, jni_double_vector, Nbr2);
2682
2683         /*
2684          * Foreground color
2685          * It has no apparent effect in Scilab 5.3.X and is therefore
2686          * commented out for now.
2687          */
2688 #if 0
2689         tmp = (int*) getGraphicObjectProperty(pparentsubwin->UID, __GO_LINE_COLOR__, jni_int);
2690         foreground = *tmp;
2691         setGraphicObjectProperty(pobj->UID, __GO_LINE_COLOR__, &foreground, jni_int, 1);
2692 #endif
2693
2694         setGraphicObjectProperty(pobj->UID, __GO_ARROW_SIZE__, &arsize, jni_double, 1);
2695
2696         for (i = 0; i < numberArrows; i++)
2697         {
2698             arrowCoords[3*i] = vfx[i];
2699             arrowCoords[3*i+1] = vfy[i];
2700             arrowCoords[3*i+2] = 0.0;
2701         }
2702
2703         setGraphicObjectProperty(pobj->UID, __GO_DIRECTION__, arrowCoords, jni_double_vector, 3*numberArrows);
2704
2705         /* typeofchamp corresponds to COLORED (0: false, 1: true) */
2706         setGraphicObjectProperty(pobj->UID, __GO_COLORED__, &typeofchamp, jni_bool, 1);
2707     }
2708
2709     /* Required to initialize the default contour properties */
2710     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
2711
2712     if (sciInitGraphicContext (pobj) == -1)
2713     {
2714         deleteGraphicObject(pobj->UID);
2715         FREE(arrowCoords);
2716         FREE(pobj);
2717         return (sciPointObj *) NULL;
2718     }
2719
2720     if ( sciAddNewHandle(pobj) == -1 )
2721     {
2722         deleteGraphicObject(pobj->UID);
2723         FREE(arrowCoords);
2724         FREE(pobj);
2725         return (sciPointObj *) NULL;
2726     }
2727
2728     setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
2729
2730     setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
2731
2732     FREE(arrowCoords);
2733
2734     return pobj;
2735 }
2736
2737
2738 /**sciConstructCompound
2739  * constructs a Compound of entities
2740  * do only a association with a parent and a handle reservation !
2741  * check for valid handle can be done using CheckForCompound
2742  */
2743 sciPointObj *
2744 ConstructCompound (long *handelsvalue, int number) /* Conflicting types with definition */
2745 {
2746   sciPointObj* compound;
2747   sciPointObj* firstMovedObject;
2748   /* Now useless */
2749 #if 0
2750   sciAgreg    * ppCompound;
2751 #endif
2752   int i;
2753   int parentVisible = 0;
2754   int *piParentVisible = &parentVisible;
2755   char* parentAxes;
2756
2757   if ((compound = MALLOC ((sizeof (sciPointObj)))) == NULL)
2758   {
2759     return (sciPointObj *) NULL;
2760   }
2761
2762   compound->UID = createGraphicObject(__GO_COMPOUND__);
2763
2764   /* To be deleted */
2765 #if 0
2766   if ( sciStandardBuildOperations( compound, sciGetParent(sciGetPointerFromHandle( (long) handelsvalue[0])) ) == NULL )
2767   {
2768     FREE( compound->pfeatures ) ;
2769     FREE( compound) ;
2770     return NULL ;
2771   }
2772 #endif
2773
2774   /* Adding the Compound's handle was previously done by sciStandardBuildOperations */
2775   if (sciAddNewHandle(compound) == -1)
2776   {
2777     deleteGraphicObject(compound->UID);
2778     FREE(compound);
2779     return NULL;
2780   }
2781
2782   /* The Compound's parent Axes is considered to be the Compound's first child's own parent */
2783   firstMovedObject = sciGetPointerFromHandle( (long) handelsvalue[0]);
2784   getGraphicObjectProperty(firstMovedObject->UID, __GO_PARENT__, jni_string, &parentAxes);
2785
2786   /* Set the parent-child relationship between the Compound and each aggregated object */
2787   for ( i = 0 ; i < number ; i++ )
2788   {
2789     sciPointObj* movedObject = sciGetPointerFromHandle( (long) handelsvalue[i]);
2790
2791     setGraphicObjectRelationship(compound->UID, movedObject->UID);
2792   }
2793
2794   /* Sets the parent-child relationship for the Compound */
2795   setGraphicObjectRelationship(parentAxes, compound->UID);
2796
2797   /* Deactivated */
2798 #if 0
2799   ppCompound->callback = (char *)NULL;
2800   ppCompound->callbacklen = 0;
2801 #endif
2802
2803   /*
2804    * To be checked: difference between sciGetParentSubwin and directly getting
2805    * the Compound's parent's visible property
2806    */
2807 #if 0
2808   ppCompound->visible = sciGetVisibility(sciGetParentSubwin(compound));
2809 #endif
2810
2811   getGraphicObjectProperty(parentAxes, __GO_VISIBLE__, jni_bool, &piParentVisible);
2812   setGraphicObjectProperty(compound->UID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
2813
2814  /*
2815   * Not implemented within the MVC yet
2816   * To be implemented
2817   */
2818 #if 0
2819   ppCompound->isselected = TRUE;
2820 #endif
2821
2822   return (sciPointObj *) compound;
2823 }
2824
2825 /**sciConstructCompoundSeq
2826  * constructs a Compound of with the last n entities created in the current subwindow
2827  on entry the subwin children list is
2828  s1->s2->...->sn->sn+1->...->sN
2829  with sn the least recent of the last n entities created and s1 the most recent one
2830  (that is, the last entity created), and N the subwin's initial number of children
2831  on exit it is
2832  A->sn+1->sn+2->...->sN
2833  with A a Compound object whose children list is:
2834  s1->s2->...->sn-1->sn
2835 */
2836 sciPointObj *
2837 ConstructCompoundSeq (int number)
2838 {
2839     char** children;
2840     char* parentFigure;
2841     int numberChildren = 0;
2842     int piNumberChildren = &numberChildren;
2843     int i;
2844     int visible = 0;
2845     int piVisible = &visible;
2846
2847     sciPointObj *pobj;
2848     sciPointObj *psubwin;
2849
2850     psubwin = sciGetCurrentSubWin();
2851
2852     /* Creates the Compound object A */
2853     if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
2854     {
2855         return NULL;
2856     }
2857
2858     pobj->UID = createGraphicObject(__GO_COMPOUND__);
2859
2860     /* Adding the Compound's handle was previously done by sciStandardBuildOperations */
2861     if (sciAddNewHandle(pobj) == -1)
2862     {
2863         deleteGraphicObject(pobj->UID);
2864         FREE(pobj);
2865         return NULL;
2866     }
2867
2868     getGraphicObjectProperty(psubwin->UID, __GO_CHILDREN_COUNT__, jni_int, &piNumberChildren);
2869
2870     getGraphicObjectProperty(psubwin->UID, __GO_CHILDREN__, jni_string_vector, &children);
2871
2872     /*
2873      * Remove the last "number" created objects (located at the children list's head)
2874      * and add them to the compound in the same order
2875      */
2876     for ( i = 0 ; i < number ; i++ )
2877     {
2878         /*
2879          * Set the parent-child relationship between the Compound and each aggregated object.
2880          * Children are added to the Compound from the least recent to the most recent, to
2881          * preserve their former ordering.
2882          */
2883         setGraphicObjectRelationship(pobj->UID, children[number-i-1]);
2884     }
2885
2886     /* Sets the parent-child relationship for the Compound */
2887     setGraphicObjectRelationship(psubwin->UID, pobj->UID);
2888
2889     /* set Compound properties*/
2890     /* To be implemented */
2891 #if 0
2892     initUserData(pobj);
2893     ppagr->callback = (char *)NULL;
2894     ppagr->callbacklen = 0;
2895 #endif
2896
2897     /*
2898      * visibility is obtained from the parent Figure, whereas it is retrieved from the
2899      * parent Axes in ConstructCompound.
2900      * To be made consistent.
2901      */
2902     getGraphicObjectProperty(pobj->UID, __GO_PARENT_FIGURE__, jni_string, &parentFigure);
2903     getGraphicObjectProperty(parentFigure, __GO_VISIBLE__, jni_bool, &piVisible);
2904
2905     setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
2906
2907     /* To be implemented */
2908 #if 0
2909     ppagr->isselected = TRUE;
2910 #endif
2911
2912     return (sciPointObj *)pobj;
2913 }
2914
2915
2916
2917 /**ConstructLabel
2918  * This function creates Label structure used for x,y,z labels and for the Title.
2919  * @param  sciPointObj *pparentsubwin
2920  * @param  char text[] : intial text string.
2921  * @param  int type to get info. on the type of label
2922  * @return  : pointer sciPointObj if ok , NULL if not
2923  */
2924 sciPointObj *
2925 ConstructLabel (sciPointObj * pparentsubwin, char *text, int type)
2926 {
2927   sciPointObj * pobj = NULL;
2928   /* get a pointer on the feature */
2929   sciLabel    * ppLabel ;
2930   char * emptyString = "" ;
2931   int defaultColor = 0 ;
2932
2933   if (sciGetEntityType (pparentsubwin) == SCI_SUBWIN)
2934   {
2935     if ((pobj = MALLOC (sizeof (sciPointObj))) == NULL)
2936     {
2937       return (sciPointObj *) NULL;
2938     }
2939
2940     sciSetEntityType (pobj, SCI_LABEL);
2941     if ((pobj->pfeatures = MALLOC ((sizeof (sciLabel)))) == NULL)
2942     {
2943       FREE(pobj);
2944       return (sciPointObj *) NULL;
2945     }
2946
2947     ppLabel = pLABEL_FEATURE( pobj ) ;
2948
2949     ppLabel->text = allocateText( pparentsubwin, &emptyString, 1, 1,
2950                                   0.0, 0.0, TRUE, NULL, FALSE, &defaultColor, &defaultColor,
2951                                   FALSE, FALSE, FALSE, ALIGN_LEFT ) ;
2952
2953                 /* RelationShip is actually stored in the text object */
2954                 pobj->relationShip = ppLabel->text->relationShip;
2955
2956     sciStandardBuildOperations(pobj, pparentsubwin);
2957
2958     /* labels are not clipped */
2959     sciSetIsClipping(ppLabel->text, -1) ;
2960
2961     /* Use centered mode */
2962     sciInitCenterPos(ppLabel->text, FALSE);
2963     sciInitAutoSize(ppLabel->text, TRUE);
2964
2965     /* 1.0 for logarithmic mode */
2966     sciInitTextPos(pobj, 1.0, 1.0, 1.0);
2967
2968     sciInitIsFilled(pobj,FALSE); /* by default a simple text is display (if existing) */
2969
2970     sciInitIs3d( pobj, FALSE ) ; /* the text of labels is displayed using 2d scale */
2971
2972     ppLabel->ptype = type;
2973     ppLabel->auto_position = TRUE;
2974     ppLabel->auto_rotation = TRUE;
2975
2976     ppLabel->isselected = TRUE;
2977
2978     return pobj;
2979   }
2980   else
2981   {
2982     Scierror(999, _("The parent has to be a SUBWIN\n"));
2983     return (sciPointObj *) NULL;
2984   }
2985 }
2986 /*----------------------------------------------------------------------------*/
2987 /**
2988  * contains the functions always called when creating an object
2989  * pObj should have just been allocated.
2990  * @return the modified object. Should be the same as pObj, unless an error occured.
2991  *         then it is NULL.
2992  */
2993 sciPointObj * sciStandardBuildOperations( sciPointObj * pObj, sciPointObj * parent )
2994 {
2995
2996         /* Allocate relationShip */
2997         createDefaultRelationShip(pObj);
2998
2999   /* add the handle in the handle list */
3000   if ( sciAddNewHandle(pObj) == -1 )
3001   {
3002     return NULL ;
3003   }
3004
3005
3006   /* connect the object under its parent in the hierarchy */
3007   if ( !sciAddThisToItsParent( pObj, parent) )
3008   {
3009     sciDelHandle(pObj) ;
3010     return NULL ;
3011   }
3012
3013   sciInitVisibility( pObj, TRUE ) ;
3014
3015   initUserData(pObj);
3016
3017   pObj->pObservers = DoublyLinkedList_new() ;
3018   createDrawingObserver( pObj ) ;
3019
3020
3021   pObj->pDrawer = NULL ;
3022
3023   return pObj ;
3024
3025 }
3026 /*----------------------------------------------------------------------------*/
3027 /**
3028  * Create a figure if none exists.
3029  */
3030 void SciWin(void)
3031 {
3032   if (!sciHasFigures())
3033   {
3034     sciGetCurrentFigure();
3035   }
3036 }
3037 /*----------------------------------------------------------------------------*/
3038 /**
3039  * Create a new figure with already a subwindow inside and show it.
3040  * When creating a new figure this mehod mut be called
3041  * @param winNum if not NULL a pointer to the figure number otherwise
3042  *               a default figure number is chosen.
3043  * @return a pointer on the created figure or NULL if the creation could
3044  *         not be performed
3045  */
3046 sciPointObj * createFullFigure(int * winNum)
3047 {
3048     sciPointObj *pNewFigure = MALLOC(sizeof(sciPointObj));
3049     pNewFigure->UID = createGraphicObject(__GO_FIGURE__);
3050     setGraphicObjectProperty(pNewFigure->UID, __GO_ID__, winNum, jni_int, 1);
3051     createJoGLView(pNewFigure->UID);
3052     sciAddNewHandle(pNewFigure);
3053     return pNewFigure;
3054
3055 #ifdef __OLD_IMPLEMENTATION__
3056   sciPointObj * newFig = NULL;
3057   sciPointObj * newSubwin = NULL;
3058
3059   /* Check that environement is OK for creating a window */
3060   if (!sciGetIsAbleToCreateWindow())
3061   {
3062     return NULL;
3063   }
3064
3065
3066   /* Create figure */
3067   newFig = ConstructFigure(NULL, winNum);
3068
3069   startFigureDataWriting(newFig);
3070
3071   if (newFig == NULL)
3072   {
3073     endFigureDataWriting(newFig);
3074     return NULL;
3075   }
3076
3077   sciSetCurrentFigure(newFig);
3078
3079   /* Add a subwindow inside the figure */
3080   if (createFirstSubwin(newFig) == NULL)
3081   {
3082     DestroyFigure(newFig);
3083     endFigureDataWriting(newFig);
3084     return NULL;
3085   }
3086
3087   endFigureDataWriting(newFig);
3088
3089
3090
3091   /* show th enewly created window */
3092   showWindow(newFig);
3093
3094
3095   return newFig;
3096 #endif
3097 }
3098 /*----------------------------------------------------------------------------*/
3099 /**
3100  * Get the first subwin object within a figure.
3101  * If not exists, create one withj default value.
3102  * @return the first subwin or NULL if an error occured during subwin creation
3103  */
3104 sciPointObj * createFirstSubwin(sciPointObj * pFigure)
3105 {
3106         if (sciGetNbTypedObjects(pFigure, SCI_SUBWIN) > 0)
3107         {
3108                 /* return the first object */
3109                 return sciGetFirstTypedSelectedSon(pFigure, SCI_SUBWIN);
3110         }
3111         else
3112         {
3113                 /* No subwins, create the default one */
3114                 sciPointObj * newSubwin = ConstructSubWin(pFigure);
3115                 if (newSubwin != NULL)
3116                 {
3117                         sciSetCurrentObj(newSubwin);
3118                         sciSetOriginalSubWin(pFigure, newSubwin);
3119                         return newSubwin;
3120                 }
3121                 else
3122                 {
3123                         return NULL;
3124                 }
3125         }
3126 }
3127 /*----------------------------------------------------------------------------*/
3128 void createDefaultRelationShip(sciPointObj * pObj)
3129 {
3130         /* Create a new relationship structure */
3131         sciRelationShip * relationShip = NULL;
3132         if(sciGetEntityType(pObj) == SCI_LABEL)
3133         {
3134                 /* labels have their relationShip stored in their text objects */
3135                 return;
3136         }
3137
3138         relationShip = MALLOC(sizeof(sciRelationShip));
3139         if (relationShip == NULL)
3140         {
3141                 return;
3142         }
3143
3144         /* Set default values */
3145         relationShip->handleIndex = 0;
3146         relationShip->plastsons = NULL;
3147         relationShip->psons = NULL;
3148         relationShip->pparent = NULL;
3149         relationShip->pSelectedSon = DoublyLinkedList_new();
3150
3151         /* Add it to the object */
3152         pObj->relationShip = relationShip;
3153
3154 }
3155 /*----------------------------------------------------------------------------*/
3156 /**
3157  * Initialize the user data of a graphic obj
3158  */
3159 void initUserData(sciPointObj * pObj)
3160 {
3161         int ** userData = NULL ;
3162   int *  udSize   = NULL ;
3163
3164         sciGetPointerToUserData( pObj, &userData, &udSize ) ;
3165   *userData = NULL ;
3166   *udSize   = 0    ;
3167 }
3168 /*----------------------------------------------------------------------------*/