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