Cut up scidrawobj routine. One routine was created for each kind of handle.
Jean-baptiste Silvy [Wed, 20 Dec 2006 16:22:57 +0000 (16:22 +0000)]
77 files changed:
scilab/modules/graphics/graphics.vcproj
scilab/modules/graphics/includes/Axes.h
scilab/modules/graphics/includes/BasicAlgos.h
scilab/modules/graphics/includes/DrawObjects.h
scilab/modules/graphics/includes/GetProperty.h
scilab/modules/graphics/includes/Plo2d.h
scilab/modules/graphics/includes/Plo2d1.h
scilab/modules/graphics/includes/Plo3d.h
scilab/modules/graphics/includes/PloEch.h
scilab/modules/graphics/includes/Xcall1.h
scilab/modules/graphics/includes/axesScale.h [new file with mode: 0644]
scilab/modules/graphics/includes/clipping.h
scilab/modules/graphics/src/c/Axes.c
scilab/modules/graphics/src/c/BasicAlgos.c
scilab/modules/graphics/src/c/Contour.c
scilab/modules/graphics/src/c/DrawObjects.c
scilab/modules/graphics/src/c/FeC.c
scilab/modules/graphics/src/c/Fec.h [new file with mode: 0644]
scilab/modules/graphics/src/c/GetProperty.c
scilab/modules/graphics/src/c/GraphicZoom.c [new file with mode: 0644]
scilab/modules/graphics/src/c/GraphicZoom.h [new file with mode: 0644]
scilab/modules/graphics/src/c/Gray.c
scilab/modules/graphics/src/c/Gray.h [new file with mode: 0644]
scilab/modules/graphics/src/c/Plo2d.c
scilab/modules/graphics/src/c/Plo2d2.c
scilab/modules/graphics/src/c/Plo2d3.c
scilab/modules/graphics/src/c/Plo2d4.c
scilab/modules/graphics/src/c/Plo2dEch.c
scilab/modules/graphics/src/c/Plo2dEch.h
scilab/modules/graphics/src/c/Plo2dn.c
scilab/modules/graphics/src/c/Plo3d.c
scilab/modules/graphics/src/c/Plo3dn.c
scilab/modules/graphics/src/c/Plo3dn.h [new file with mode: 0644]
scilab/modules/graphics/src/c/Rec.c
scilab/modules/graphics/src/c/RecLoad.c
scilab/modules/graphics/src/c/Vertices.c [new file with mode: 0644]
scilab/modules/graphics/src/c/Vertices.h [new file with mode: 0644]
scilab/modules/graphics/src/c/Xcall.c
scilab/modules/graphics/src/c/Xcall1.c
scilab/modules/graphics/src/c/axesScale.c [new file with mode: 0644]
scilab/modules/graphics/src/c/clipping.c
scilab/modules/graphics/src/c/drawMarks.c [new file with mode: 0644]
scilab/modules/graphics/src/c/drawMarks.h [new file with mode: 0644]
scilab/modules/graphics/src/c/graphicModuleStart.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawArcEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawArcEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawAxesEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawAxesEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawCompoundEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawCompoundEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawFecEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawFecEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawFigureEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawFigureEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawGrayplotEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawGrayplotEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawLegendEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawLegendEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawMergeEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawMergeEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawPolylineEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawPolylineEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawRectangleEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawRectangleEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawSegsEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawSegsEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawSubWinEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawSubWinEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawSurfaceEntity.c [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawSurfaceEntity.h [new file with mode: 0644]
scilab/modules/graphics/src/c/handleDrawing/drawTextEntity.c
scilab/modules/graphics/src/c/handleDrawing/drawTextEntity.h
scilab/modules/graphics/src/c/periFig.c
scilab/modules/graphics/src/c/periGif.c
scilab/modules/graphics/src/c/periPos.c
scilab/modules/graphics/src/c/periWin.c
scilab/modules/graphics/src/c/sciCall.c

index dd88407..14be351 100644 (file)
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\axesScale.c"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\src\c\BasicAlgos.c"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\handleDrawing\drawArcEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawAxesEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawCompoundEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawFecEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawFigureEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawGrayplotEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawLegendEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\drawMarks.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawMergeEntity.c"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\src\c\DrawObjects.c"
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\handleDrawing\drawPolylineEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawRectangleEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawSegsEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawSubWinEntity.c"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawSurfaceEntity.c"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\src\c\handleDrawing\drawTextEntity.c"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\GraphicZoom.c"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\src\c\Gray.c"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\Vertices.c"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\src\c\WindowList.c"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\includes\axesScale.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\includes\BasicAlgos.h"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\handleDrawing\drawArcEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawAxesEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawCompoundEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawFecEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawFigureEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawGrayplotEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawLegendEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\drawMarks.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawMergeEntity.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\includes\DrawObjects.h"
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\handleDrawing\drawPolylineEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawRectangleEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawSegsEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawSubWinEntity.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\handleDrawing\drawSurfaceEntity.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\src\c\handleDrawing\drawTextEntity.h"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\Fec.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\includes\Format.h"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\GraphicZoom.h"
+                               >
+                       </File>
+                       <File
+                               RelativePath=".\src\c\Gray.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\includes\gsort.h"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\Plo3dn.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\includes\PloEch.h"
                                >
                        </File>
                                >
                        </File>
                        <File
+                               RelativePath=".\src\c\Vertices.h"
+                               >
+                       </File>
+                       <File
                                RelativePath=".\includes\WindowList.h"
                                >
                        </File>
index 134ba3b..a64c777 100644 (file)
@@ -124,5 +124,15 @@ void updateScaleIfRequired( sciPointObj * pSubWin ) ;
  */
 void drawAxesGrid( sciPointObj * psubwin ) ;
 /*--------------------------------------------------------------------------------------*/
+extern void axis_3ddraw(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD); /* DRAWINGS */
+extern void triedre(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD); /* DRAWINGS */
+void DrawAxesBackground( void ) ;
+int labels2D_draw( sciPointObj * psubwin ) ;
+void rebuild_strflag( sciPointObj * psubwin, char * STRFLAG) ;
+void axis_draw2(char strflag[]) ;
+void Sci_Axis(char pos, char xy_type, double *x, int *nx, double *y, int *ny,
+              char *str[], int subtics, char *format, int fontsize, int textcolor, 
+              int fontstyle, int ticscolor, char logflag, int seg_flag, int axisbuild_flag) ;
+/*--------------------------------------------------------------------------------------*/
 
 #endif /*__SCI_AXES_H_*/
index 8a71f31..9cfbb7a 100644 (file)
@@ -71,6 +71,11 @@ double * createNewArrayFromSource( int destSize, const double src[], int srcSize
 void destroyStringArray( char * src[], int nbStrings ) ;
 
 /**
+ * allocate a copy of a double array
+ */
+double * createDoubleArrayCopy( const double src[], int nbElement ) ;
+
+/**
  * allocate a copy of a int array.
  */
 int * createIntArrayCopy( const int src[], int nbElement ) ;
index f57c02f..77f03cb 100644 (file)
@@ -35,18 +35,6 @@ extern void GPopupResize (struct BCG * ScilabXgc,int * width,int * height);
 
 void set_cf_type( int val ) ;
 
-extern void newfec __PARAMS((integer *xm,integer *ym,double *triangles,double *func,integer *Nnode,
-                            integer *Ntr,double *zminmax, integer *colminmax, integer *colout, BOOL with_mesh));
-extern void GraySquare1(integer *x, integer *y, double *z, integer n1, integer n2);
-extern void GraySquare1_NGreverse(integer *x, integer *y, double *z, integer n1, integer n2, sciPointObj * psubwin);
-
-extern void GraySquare(integer *x, integer *y, double *z, integer n1, integer n2);
-extern void GraySquareDirect(integer *x, integer *y, double *z, integer n1, integer n2); /* for NG, grayplot direct mode */
-extern void GraySquareScaled(integer *x, integer *y, double *z, integer n1, integer n2); /* for NG, grayplot direct mode */
-extern void Plo2d1RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf);
-extern void Plo2d2RealToPixel __PARAMS((integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf));
-extern void Plo2d3RealToPixel __PARAMS((integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf));
-extern void Plo2d4RealToPixel __PARAMS((integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf));
 
 
 char ** FreeUserLabels(char ** u_xlabels, int *u_nxgrads);
@@ -76,16 +64,11 @@ extern void sciXdraw(void);  /* DRAWINGS */
 /* 3 next are in plo3d.c*/
 extern void SetEch3d1(double *xbox, double *ybox, double *zbox, double *bbox, double *teta, double *alpha, integer flag); /* DRAWINGS */
 extern void Convex_Box(double *xbox, double *ybox, integer *InsideU, integer *InsideD, char *legend, integer *flag, double *bbox); /* DRAWINGS */
-extern void DrawAxis(double *xbox, double *ybox, integer *Indices, integer style); /* DRAWINGS */
 
-extern void axis_3ddraw(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD); /* DRAWINGS */
-extern void triedre(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD); /* DRAWINGS */
 extern void Nextind(integer ind1, integer *ind2, integer *ind3); /* DRAWINGS */
-extern int trans3d(sciPointObj *pobj,integer n,integer *xm,integer *ym,double *x, double *y,double *z); /* DRAWINGS */
 extern int GradLog(double _min, double _max, double *_grads, int * n_grads, int compNgrads );
 extern BOOL Ishidden(sciPointObj *pobj); /* DRAWINGS */
 extern BOOL IsDownAxes(sciPointObj *pobj); /* DRAWINGS */
-extern void Plo2dTo3d(integer type, integer *n1, integer *n2, double *x, double *y, double *z, double *x1, double *y1, double *z1); /* DRAWINGS */
 extern void sciGetDisplayedBounds( sciPointObj * pSubWin,
                                    double      * xmin   ,
                                    double      * xmax   ,
@@ -101,9 +84,6 @@ extern void updateScale3d( sciPointObj * pobj    ,
 extern BOOL sci_update_frame_bounds_3d(sciPointObj *pobj);  /* DRAWINGS */
 extern BOOL sci_update_frame_bounds_2d(sciPointObj *pobj);  /* DRAWINGS */
 
-extern void rebuild_strflag( sciPointObj * psubwin, char * STRFLAG); /* DRAWINGS */
-extern int labels2D_draw(sciPointObj * psubwin); /* DRAWINGS */
-
 extern int ComputeNbSubTics(sciPointObj * pobj, int nbtics, char logflag, double * grads, int nbsubtics_input); /* DRAWINGS */
 extern int ComputeNbSubTicsFor3dUse(sciPointObj * pobj, int nbtics, char logflag, double * grads, int nbsubtics_input);
 extern int ComputeCorrectXindAndInsideUD(double Teta,double Alpha, double * dbox, integer *xind, integer *InsideU, integer *InsideD); /* DRAWINGS */
@@ -119,22 +99,12 @@ extern int CheckDisplay(double fact_h, double fact_w, char logflag, char *foo,in
 extern int IsInsideRectangle(int * rect, int *point);
 
 extern int CheckIfiisNan(int j, int dim, int * tab); /* DRAWINGS */
-extern int  BuildXYZvectForClipping_IfNanOrLogON(sciPointObj *ppolyline, sciPointObj * psubwin, int * nb_curves, 
-                                                double *** xvect, double *** yvect, double *** zvect, int ** curves_size); /* DRAWINGS */
 extern int ComputeGoodTrans3d( sciPointObj * psubwin, int n, int *xm, int *ym, double * fx, double *fy, double *fz); /* DRAWINGS */
-extern double InvAxis(double min, double max, double u); /* DRAWINGS */
-extern int ReverseDataFor3D(sciPointObj * psubwin, double * xvect, double * yvect, double * zvect, int n1); /* DRAWINGS */
-extern int ReverseDataFor3DXonly(sciPointObj * psubwin, double * xvect, int n1); /* DRAWINGS */
-extern int ReverseDataFor3DYonly(sciPointObj * psubwin, double * yvect, int n1); /* DRAWINGS */
-extern int ReverseDataFor3DZonly(sciPointObj * psubwin, double * zvect, int n1); /* DRAWINGS */
 extern void DrawAxesIfRequired(sciPointObj*); /* DRAWINGS */
 extern void DrawAxes(sciPointObj*); /* DRAWINGS */
 
 extern void UpdateSubwinScale(sciPointObj * pobj); /* DRAWINGS */
 
-extern void sciClip (sciPointObj *pobj); /* DRAWINGS */
-extern void sciUnClip (sciPointObj *pobj); /* DRAWINGS */
-
 extern int sciDrawObj (sciPointObj * pobj); /* DRAWINGS */
 extern int sciDrawObjIfRequired (sciPointObj * pobj); /* DRAWINGS */
 extern int sciRefreshObj( sciPointObj * pobj ) ; /* DRAWINGS */
@@ -147,42 +117,18 @@ extern int ComputeXIntervals(sciPointObj *pobj, char xy_type, double **vector, i
 
 /*F.Leray : Format pour imprimer un nombre de la forme k10^a ; cf. Axes.c*/
 extern void NumberFormat __PARAMS((char *str,integer k,integer a));
-extern void C2F(plot3dn)(sciPointObj *pobj, 
-                        double *x, double *y, double *z, 
-                        integer *p, integer *q, int *DPI);
 
-extern void C2F(fac3dn)(sciPointObj *pobj, 
-                       double *x, double *y, double *z, 
-                       double *cvect, integer *p, integer *q, int *DPI);
 /**DJ.Abdemouche 2003**/
 
 extern int Gen3DPoints (integer type,integer *polyx,integer *polyy,integer *fill,integer whiteid,double zmin,double zmax,double *,double *,double *,integer i,integer j,integer jj1,integer *p,integer dc,integer fg, sciPointObj *psurface); /* DRAWINGS */
 extern void Merge3d(sciPointObj *psubwin);/*DJ.A merge*/   /* DRAWINGS */
 extern void Merge3dBuildTable(sciPointObj *pparent, int *index_in_entity, long *from_entity, int *pos);
 extern int Merge3dDimension(sciPointObj *pparent);
-extern void DrawMerge3d(sciPointObj *psubwin, sciPointObj *pmerge, int *DPI);  /* DRAWINGS */
 
-extern int DrawNewMarks(sciPointObj * pobj, int n1, int *xm, int *ym, int *DPI);
-extern void DrawMarks3D(sciPointObj *pobj, int n1, int *xm, int *ym, int *DPI);
 extern int CheckPixelStatus(void);
 
-extern int DrawMark_FullDot(int x1, int yy1, double size, int foreground, int background, int pixel_offset);
-extern int DrawMark_Plus(int xmi, int ymi, int size, int foreground, int pixel_offset);
-extern int DrawMark_Cross(int xmi, int ymi, int size, int foreground, int pixel_offset);
-extern int DrawMark_FullDiamond(int xmi, int ymi, int size, int foreground, int background);
-extern int DrawMark_FullTriangleUp(int xmi, int ymi, int size, int foreground, int background);
-extern int DrawMark_FullTriangleDown(int xmi, int ymi, int size, int foreground, int background);
-extern int DrawMark_Asterisk(int xmi, int ymi, int size, int foreground, int pixel_offset);
-extern int DrawMark_FullSquare(int xmi, int ymi, int size, int foreground, int background, int pixel_offset);
-extern int DrawMark_FullTriangleRight(int xmi, int ymi, int size, int foreground, int background);
-extern int DrawMark_FullTriangleLeft(int xmi, int ymi, int size, int foreground, int background);
-extern int DrawMark_FullPentagram(int xmi, int ymi, int size, int foreground, int background);
 extern int GetDPIFromDriver(int * DPI);
 extern int ChooseFormatForOneGrad(char *c_format, double *grad);
-extern int SetMinMaxVertices(Vertices *vertices_list, double *xmin, double *ymin, double *zmin, double *xmax, double *ymax, double *zmax);
-extern int GetVerticesAt(Vertices *vertices_list, int *xm, int *ym, double *x, double *y, double *z);
-extern int RemoveNext(Vertices *pCurrent);
-extern int FreeVertices(sciPointObj * psubwin);
 extern int ChildrenCounter(sciPointObj *pparent);
 extern int GetBarNumber(sciPointObj * pobj);
 extern double FindWidth(sciPointObj * pobj, int n1, int bar_number, double *x);
@@ -197,21 +143,11 @@ extern void sciAxesVerticesIndices( integer insideU[4],
 
 extern void matrixLine2String( char ** matrix, int matrixSize[2], int numLine, char * dest ) ;
 
-extern void rectangleDouble2Pixel( sciPointObj * parentSubWin ,
-                                   double        ulPoint[3]   ,
-                                   double        userSize[2]  ,
-                                   int           edgesX[4]    ,
-                                   int           edgesY[4]     ) ;
 
 void computeLabelAutoPos( sciPointObj * pLabel, int axisStart[2], int axisEnd[2], int offsets[2] ) ;
 
 void sciDrawFigure( int numFigure ) ;
 
-extern void drawPolyMarks( sciPointObj * pObj    ,
-                          int           nbMarks ,
-                          int           xCoord[],
-                          int           yCoord[],
-                          int         * DPI      ) ;
 
 extern int computeRealArrowSize( sciPointObj * pSegs,
                                 int nbSegs         ,
index 793b002..890858e 100644 (file)
@@ -14,6 +14,7 @@
 #include "ObjectStructure.h"
 #include "HandleManagement.h"
 #include "StringMatrix.h"
+#include "bcg.h"
 
 #ifndef __SCI_GET_PROPERTY__
 #define __SCI_GET_PROPERTY__
index 4dd8819..e1d5a68 100644 (file)
@@ -6,6 +6,8 @@
 *    Jean-Baptiste Silvy
 --------------------------------------------------------------------------*/
 
+#include "machine.h"
+
 int C2F(plot2d)(double    x[]      ,
                 double    y[]      ,
                 integer * n1       ,
@@ -19,3 +21,5 @@ int C2F(plot2d)(double    x[]      ,
                 integer   lstr2     ) ;
 
 int C2F(xgrid)( integer * style ) ;
+
+void Legends( integer * style, integer * n1, char * legend ) ;
index b1d685e..d0ecf1b 100644 (file)
@@ -13,5 +13,8 @@ int C2F(plot2d2)(char *xf, double *x, double *y, integer *n1, integer *n2, integ
 int C2F(plot2d3)(char *xf, double *x, double *y, integer *n1, integer *n2, integer *style, char *strflag, char *legend, double *brect, integer *aaint, integer l1, integer l2, integer l3) ;
 int C2F(plot2d4)(char *xf, double *x, double *y, integer *n1, integer *n2, integer *style, char *strflag, char *legend, double *brect, integer *aaint, integer l1, integer l2, integer l3) ;
 
+void Plo2d2RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf) ;
+void Plo2d3RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf) ;
+void Plo2d4RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf) ;
 
 #endif /* _PLO2D1_H_ */
index 2929034..2d20993 100644 (file)
@@ -37,4 +37,6 @@ void AxesStrings(integer axflag, integer *ixbox, integer *iybox, integer *xind,
 
 int  triangleSort(integer *polyxin, integer *polyyin, integer *fillin, integer *polyx, integer *polyy, integer *fill);
 
+int scilab_shade(integer *polyx, integer *polyy, integer *fill, integer polysize, integer flag) ;
+
 #endif /* _PLO3D_H_ */
index 73ebcaa..8540325 100644 (file)
@@ -137,6 +137,9 @@ extern double YDPi2R( double y ) ;
 #define GEOX(x1,y1,z1)  XScale(TRX(x1,y1,z1))
 #define GEOY(x1,y1,z1)  YScale(TRY(x1,y1,z1))
 
+#define TX3D(x1,y1,z1) Cscale.Wscx1*(TRX(x1,y1,z1)-Cscale.frect[0]) +Cscale.Wxofset1 ;
+#define TY3D(x1,y1,z1) Cscale.Wscy1*(-TRY(x1,y1,z1)+Cscale.frect[3])+Cscale.Wyofset1 ;
+
 /**
 * convert the coordinates of a 2d or 3d point to its pixel coordinates.
 * @param pSubWin SubWindow in which the point is, might be either in 2d or 3d.
index 5454a04..565be9c 100644 (file)
@@ -27,6 +27,10 @@ int GetDriverId( void ) ;
 
 void C2F(SetDriver)(char *x0, integer *v2,integer * v3,integer * v4, integer *v5,integer * v6, integer * v7,double * dv1,double * dv2,double * dv3,double * dv4);
 
-
+/**
+ *we draw marks in pixel
+ * Returns the DPI depending on the used driver
+ */
+int GetDPIFromDriver( int DPI[2] ) ;
 
 #endif /* _XCALL1_H_ */
diff --git a/scilab/modules/graphics/includes/axesScale.h b/scilab/modules/graphics/includes/axesScale.h
new file mode 100644 (file)
index 0000000..238a8a5
--- /dev/null
@@ -0,0 +1,30 @@
+/*------------------------------------------------------------------------*/
+/* file: axesScale.h                                                      */
+/* Copyright INRIA 2006                                                   */
+/* Authors : Jean-Baptiste Silvy                                          */
+/* desc : Contains functions to compute scale changes in a specific       */
+/*        subwindow.                                                      */
+/*------------------------------------------------------------------------*/
+
+#ifndef _AXES_SCALE_H_
+#define _AXES_SCALE_H_
+
+#include "ObjectStructure.h"
+
+/*---------------------------------------------------------------------------------------*/
+double InvAxis( double min, double max, double u ) ;
+int ReverseDataFor3DXonly( sciPointObj * psubwin, double xvect[], int n1 ) ;
+int ReverseDataFor3DYonly( sciPointObj * psubwin, double yvect[], int n1 ) ;
+int ReverseDataFor3DZonly( sciPointObj * psubwin, double zvect[], int n1 ) ;
+int ReverseDataFor3D(      sciPointObj * psubwin, double xvect[], double yvect[], double zvect[], int n1 ) ;
+/*---------------------------------------------------------------------------------------*/
+int trans3d( sciPointObj * pobj,
+             integer       n   ,
+             integer       xm[],
+             integer       ym[],
+             double        x[] ,
+             double        y[] ,
+             double        z[]  ) ;
+/*---------------------------------------------------------------------------------------*/
+
+#endif /* _AXES_SCALE_H_ */
index ccdc6dd..f7c42d1 100644 (file)
@@ -98,5 +98,31 @@ void C2F(clipPolyLine)( integer       n     ,
  */
 void getPixelClipping( sciPointObj * pObj, SClipRegion * clipping ) ;
 /*----------------------------------------------------------------------------------------*/
+/**
+ * Set the clipping rectangl.
+ * Note that clipping is not supported at all in 3D mode for now :
+ * This assertion includes axes (in 3D), surfaces and parametric curves objects.
+ * @author Djalel ABDEMOUCHE
+ * 29/11/2002
+ */
+void sciClip ( sciPointObj * pobj ) ;
+
+/**
+ * Clear the clipping rectangle 
+ * @author Djalel ABDEMOUCHE
+ * 29/11/2002
+ */
+void sciUnClip ( sciPointObj * pobj ) ;
+/*----------------------------------------------------------------------------------------*/
+/**
+ * use current scale to set the clipping rectangle 
+ */
+void frame_clip_on(  void ) ;
+
+/**
+ * disable clipping (to be called after frame_clip_on
+ */
+void frame_clip_off( void ) ;
+/*----------------------------------------------------------------------------------------*/
 
 #endif // __SCI_CLIPPING__
index 57fb586..05509ff 100644 (file)
@@ -19,6 +19,9 @@
 #include "DrawObjects.h"
 #include "InitObjects.h"
 #include "Xcall1.h"
+#include "SetProperty.h"
+#include "handleDrawing/drawTextEntity.h"
+#include "sciprint.h"
 
 
 #include "MALLOC.h" /* MALLOC */
@@ -169,7 +172,7 @@ void axis_draw2(char strflag[])
 
 /* Only paint the area of the axes */
 /* ans does not draw any graduations or ticks, lines... */
-void DrawAxesBackground()
+void DrawAxesBackground( void )
 { 
        static sciPointObj * psubwin;
   /* using foreground to draw axis */
@@ -1211,7 +1214,7 @@ void Convex3d_Box(double *xbox, double *ybox, integer *InsideU, integer *InsideD
     }
   if (ind < 0 || ind > 8) 
     {
-      Scistring("xind out of bounds");
+      sciprint("xind out of bounds");
       xind[0]=0;
     }
   UpNext(xind[0],&ind2,&ind3);
@@ -3330,3 +3333,359 @@ void drawAxesGrid( sciPointObj * psubwin )
   }
 }
 /*-----------------------------------------------------------------------------------------*/
+/**axis_3ddraw 10/2003
+* @author Djalel Abdemouche
+* Should be in Axes.c file
+*/
+void axis_3ddraw(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD) 
+{
+  double dbox[6];
+  integer flag,i,p,n,pat,hiddencolor, x[5]; /* F. Leray : redimmensionnment (+1) du tableau x[4];*/
+  static double Alpha, Teta;
+  int verbose=0,narg;
+  integer ixbox[8],iybox[8],xind[8],dash[6];
+  integer background,zero=0, color_old; /* Adding color_old 04.03.04*/
+  sciSubWindow * ppsubwin =  pSUBWIN_FEATURE (pobj);
+  EAxesBoxType subWinBoxType = sciGetBoxType( pobj ) ;
+
+  /* Initialisation phase for x (to detect bug): x set to -1000 F.Leray 05.03.04*/
+  for(i=0;i<5;i++) { x[i] = -1000 ; }
+
+  if(sciGetEntityType (pobj) == SCI_SUBWIN)
+  {  
+
+    updateScale3d( pobj, dbox, xbox, ybox, zbox ) ;
+    /* Until here we have computed + reset the 3d scale*/
+    Teta  = ppsubwin->theta  ;
+    Alpha =  ppsubwin->alpha ;
+    if( Abs( Teta ) < 0.1 )
+    {
+      /* to avoid bug at limit when theta == 0 */
+      /* I recompute temp value xyzbox with theta == 0.1 */
+      /* to have a correct xind, InsideU et InsideD */
+      ComputeCorrectXindAndInsideUD( Teta, Alpha, dbox, xind, InsideU, InsideD ) ;
+    }
+    else
+    {
+      sciAxesVerticesIndices( InsideU, InsideD, xbox, ybox, xind ) ;
+    }
+
+    /* F.Leray Rajout 02.04.04 :*/
+    background = sciGetBackground(pobj) ;
+
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      ixbox[i]=XScale(xbox[xind[i]]);
+      iybox[i]=YScale(ybox[xind[i]]);
+    }
+    ixbox[6] = ixbox[0] ;
+    iybox[6] = iybox[0] ;
+    p = 7 ;
+    n = 1 ; 
+
+    C2F(dr)("xget","pattern",&verbose,&color_old,&zero,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+    C2F(dr)("xset","pattern",&background,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);    
+    C2F (dr) ("xarea", "v", &p, ixbox, iybox, &n, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
+    C2F(dr)("xset","pattern",&color_old,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+    /***********/
+    /***  hidden axis */
+
+    flag = ppsubwin->axes.flag[2]; /* box drawing */
+
+    if ( subWinBoxType != BT_OFF )
+    { 
+      x[2] = sciGetLineWidth (pobj);
+      x[3] = sciGetLineStyle (pobj);
+      C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+
+      hiddencolor = sciSetGoodIndex( pobj, ppsubwin->axes.hiddenAxisColor ) ;
+
+      if (zbox[InsideU[0]] > zbox[InsideD[0]])
+      {
+        DrawAxis(xbox,ybox,InsideD,hiddencolor);
+      }         
+      else
+      {
+        DrawAxis(xbox,ybox,InsideU,hiddencolor);       
+      }
+      if (Ishidden(pobj))
+      {
+        ppsubwin->hiddenstate=(InsideU[0] % 4);
+      }
+      else
+      {
+        ppsubwin->hiddenstate=(InsideD[0] % 4);
+      }
+    }
+    /**  l'enveloppe cvxe*/
+    x[0] = sciGetForeground (pobj);     /* F.Leray 05.03.04 Useless or not?? because we used set pattern instead of set foreground (because Windows uses BRUSH and PEN...)*/
+    /* Wrong explanation: We use sciGetForeground in NG mode and used set foreground in old graphic mode*/
+    x[2] = sciGetLineWidth (pobj); /* Adding this line 05.03.04*/
+    x[3] = sciGetLineStyle (pobj);
+    x[4] = 0; 
+    C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
+    C2F(dr)("xget","pattern",&verbose,&pat,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+    /* We are in axis_3ddraw() and sciGetEntityType (pobj) == SCI_SUBWIN*/
+    C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4,PI0,PD0,PD0,PD0,PD0, 5L, 6L);
+    C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,PI0,PD0,PD0,PD0,PD0,5L,4096); /* F.Leray 05.03.04 Useless too*/
+    C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+    C2F (dr) ("xset", "line style", x+3,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+
+    p = 7 ;
+    n = 1 ;
+    for ( i = 0 ; i < p ; i++ )
+    {
+      ixbox[i] = XScale( xbox[ xind[i] ] ) ;
+      iybox[i] = YScale( ybox[ xind[i] ] ) ;
+    }
+    ixbox[p-1]=ixbox[0];iybox[p-1]=iybox[0]; 
+
+    if ( subWinBoxType == BT_BACK_HALF || subWinBoxType == BT_ON )
+    {
+      C2F(dr)("xpolys","v",ixbox,iybox,x,&n,&p,PI0,PD0,PD0,PD0,PD0,0L,0L);
+
+    }
+    Axes3dStrings2(ixbox,iybox,xind) ;
+
+    C2F(dr)("xset","pattern",&pat,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+    C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+  }
+}
+/*-----------------------------------------------------------------------------------------*/
+void triedre(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD)
+{
+  integer  x[5],narg = 0;
+  integer color_kp,verbose = 0,thick_kp ;
+  integer style_kp[3] ;
+
+  C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray Replacement*/
+  C2F(dr)("xget","thickness",&verbose,&thick_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray addings here*/
+  C2F(dr)("xget","line style",&verbose,style_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray addings here*/
+
+  if(sciGetEntityType (pobj) == SCI_SUBWIN)
+  {
+    if(pSUBWIN_FEATURE (pobj)->axes.rect == BT_ON)
+    {
+      x[0] = sciGetForeground (pobj);  
+      x[2] = sciGetLineWidth (pobj);
+      x[3] = sciGetLineStyle (pobj);
+      x[4] = 0;
+
+      /* C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,PI0,PD0,PD0,PD0,PD0,5L,4096);*/
+      C2F(dr)("xset","pattern",x,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
+      C2F(dr)("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+      C2F(dr)("xset", "line style", x+3,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+
+      if (zbox[InsideU[0]] > zbox[InsideD[0]])
+      {
+        DrawAxis(xbox,ybox,InsideU,x[0]);
+      }
+      else
+      {
+        DrawAxis(xbox,ybox,InsideD,x[0]);
+      }
+    }
+  }
+  C2F(dr)("xset", "line style",&(style_kp[0]),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);/*F.Leray addings here*/
+  C2F(dr)("xset","thickness",&thick_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);/*F.Leray addings here*/
+  C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray addings here*/
+
+}
+/*-----------------------------------------------------------------------------------------*/
+/* F.Leray 07.05.04 */
+/* This routine rebuild a needed strflag for axis_draw call in sciDrawObj*/
+/* It may be less complete than the original strflag given in plot2dn (or other 2D - plot function)
+due to less info. Nevertheless this new strflag is sufficient for axis_draw because
+tests are on strflag[1] (case =='5' or '6') and strflag[2] */
+void rebuild_strflag( sciPointObj * psubwin, char * STRFLAG)
+{
+
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
+  BOOL isaxes = GetIsAxes2D(psubwin);
+
+  /* strflag[0]*/
+  STRFLAG[0] = '0'; /* flag for caption display unused here so set to NULL by default */
+  if( pSUBWIN_FEATURE (psubwin)->with_leg == 1)
+    STRFLAG[0] = '0';
+  else
+    STRFLAG[0] = '1';
+
+  /* strflag[1]*/
+  /* Here isoview mode test is not needed because axis_draw do not use it */
+  STRFLAG[1] = '0'; /* Init. to NULL <=> use the previous scale */
+  if(ppsubwin->tight_limits == TRUE)
+  {
+    STRFLAG[1] = '8';
+  }
+  else /* using auto rescale : enlarged for pretty axes*/
+  {
+    STRFLAG[1] = '6';
+  }
+
+  /* strflag[2]*/
+  STRFLAG[2] = '1'; /* Init with y-axis on the left AND axes is on*/
+  if(isaxes == TRUE)
+  {
+    if(ppsubwin->axes.ydir =='l')
+      STRFLAG[2] = '1';
+    else if(ppsubwin->axes.ydir =='r')
+      STRFLAG[2] = '3';
+    else if((ppsubwin->axes.xdir =='c') && (ppsubwin->axes.ydir =='c'))
+      STRFLAG[2] = '5';
+  }
+  else
+  {
+    if(ppsubwin->axes.rect == BT_ON)
+      STRFLAG[2] = '2';
+    else
+      STRFLAG[2] = '0';
+  }
+
+  STRFLAG[3] = '\0';
+}
+/*-----------------------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------------*/
+/* draw the title and the two labels of a 2d axis                                 */
+/*----------------------------------------------------------------------------------*/
+int labels2D_draw( sciPointObj * psubwin )
+{
+  /* Rewritten by jb Silvy 06/2006 */
+
+  integer rect1[4] ;
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
+  int offset[2] ; /* vertical and horizontal offsets to move labels a little from axes */
+
+  if ( !sciGetVisibility(psubwin) )
+  {
+    return 0 ;
+  }
+
+  /* get the size of the current subwin in pixels */
+  rect1[0]= Cscale.WIRect1[0] ; /* upper left point of the axes x coordinate. */
+  rect1[1]= Cscale.WIRect1[1] ; /* upper left point of the axes y coordinate. */
+  rect1[2]= Cscale.WIRect1[2] ; /* width of the axes */
+  rect1[3]= Cscale.WIRect1[3] ; /* height of the axes */
+
+  /* the little displacment of the labels from the axes box */
+  offset[0] = rect1[2] / 50 + 1 ;
+  offset[1] = rect1[3] / 25 + 1 ;
+
+
+  /*********/
+  /* TITLE */
+  /*********/
+
+  if ( sciGetVisibility(ppsubwin->mon_title) )
+  {
+    /* get the pointer on the title */
+    sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_title ) ;
+
+    /* get position and orientation of the title */
+    if ( ppLabel->auto_rotation )
+    {
+      sciSetFontOrientation( ppsubwin->mon_title, 0 ) ;
+    }
+
+
+    if ( ppLabel->auto_position )
+    {
+      int segmentStart[2] = { rect1[0] + rect1[2], rect1[1] } ;
+      int segmentEnd[2]   = { rect1[0]           , rect1[1] } ;
+      computeLabelAutoPos( ppsubwin->mon_title, segmentStart, segmentEnd, offset ) ;
+    }
+    /* draw the label */
+    drawTextEntity( ppLabel->text ) ;
+
+  }
+
+  /***********/
+  /* x label */
+  /***********/
+
+  if( sciGetVisibility(ppsubwin->mon_x_label) )
+  {
+    /* get the pointer on the title */
+    sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_x_label ) ;
+
+    if( ppLabel->auto_rotation )
+    {
+      sciSetFontOrientation(ppsubwin->mon_x_label, 0 ) ;
+    }
+
+
+    if( ppLabel->auto_position )
+    {
+      int segmentStart[2] ;
+      int segmentEnd[2]   ;
+
+      if(ppsubwin->axes.xdir == 'u')
+      {
+        segmentStart[0] = rect1[0] + rect1[2] ;
+        segmentEnd[0]   = rect1[0] ;
+
+        /* we add the size of the numbers to the height */
+        segmentStart[1] = ppsubwin->XGradMostOnTop ;
+        segmentEnd[1]   = ppsubwin->XGradMostOnTop ;
+      }
+      else
+      {
+        segmentStart[0] = rect1[0] ;
+        segmentEnd[0]   = rect1[0] + rect1[2] ;
+
+        segmentStart[1] = ppsubwin->XGradMostOnBottom ;
+        segmentEnd[1]   = ppsubwin->XGradMostOnBottom ;
+      }
+      computeLabelAutoPos( ppsubwin->mon_x_label, segmentStart, segmentEnd, offset ) ;
+    }
+
+    drawTextEntity( ppLabel->text ) ;
+
+  }
+
+
+  /***********/
+  /* y label */
+  /***********/
+
+
+  if ( sciGetVisibility(ppsubwin->mon_y_label) )
+  {
+    sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_y_label ) ;
+
+    if( ppLabel->auto_rotation )
+    {
+      sciInitFontOrientation( ppsubwin->mon_y_label, 270 * 10 ) ;
+    }
+
+    if( ppLabel->auto_position )
+    {
+      int segmentStart[2] ;
+      int segmentEnd[2]   ;
+
+      if(ppsubwin->axes.ydir == 'r')
+      {
+
+        /* we add the size of the numbers to the height */
+        segmentStart[0] = ppsubwin->YGradMostOnRight ;
+        segmentEnd[0]   = ppsubwin->YGradMostOnRight ;
+
+        segmentStart[1] = rect1[1] + rect1[3] ;
+        segmentEnd[1]   = rect1[1] ;
+      }
+      else
+      {
+        segmentStart[0] = ppsubwin->YGradMostOnLeft ;
+        segmentEnd[0]   = ppsubwin->YGradMostOnLeft ;
+
+        segmentStart[1] = rect1[1] ;
+        segmentEnd[1]   = rect1[1] + rect1[3] ;
+      }
+      computeLabelAutoPos( ppsubwin->mon_y_label, segmentStart, segmentEnd, offset ) ;
+    }
+    drawTextEntity( ppLabel->text ) ;
+  }
+
+  return 0;
+}
+/*-----------------------------------------------------------------------------------------*/
\ No newline at end of file
index 63373a9..00a48e7 100644 (file)
@@ -150,6 +150,20 @@ void destroyStringArray( char * src[], int nbStrings )
   FREE( src ) ;
 }
 /*-----------------------------------------------------------------------------------*/
+double * createDoubleArrayCopy( const double src[], int nbElement )
+{
+  double * res = MALLOC( nbElement * sizeof(double) ) ;
+
+  if ( res == NULL )
+  {
+    return NULL ;
+  }
+
+  memcpy( res, src, nbElement * sizeof(double) ) ;
+
+  return res ;
+}
+/*-----------------------------------------------------------------------------------*/
 int * createIntArrayCopy( const int src[], int nbElement )
 {
   int * res = MALLOC( nbElement * sizeof(int) ) ;
index e828be4..f0da5b9 100644 (file)
@@ -11,6 +11,7 @@
 #include "Graphics.h" 
 #include "PloEch.h"
 #include "Xcall1.h"
+#include "sciprint.h"
 
 #include "GetProperty.h"
 
@@ -429,7 +430,7 @@ static void contourI(ptr_level_f func, double *x, double *y, double *z, double *
   if ( (itg_cont == NULL) && n1*n2 != 0) check= 0;
   if ( check == 0) 
     {
-      Scistring("contourI_: Running out of memory\n");
+      sciprint("contourI_: Running out of memory\n");
       return;
     }
   /* just a parametrization of the boundary points */
@@ -531,7 +532,7 @@ static void look(ptr_level_f func, integer i, integer j, integer ib, integer jb,
              y_cont(j));
       break;
       default :
-       Scistring(" Error in case wrong value ");
+       sciprint(" Error in case wrong value ");
       break;
     }
   wflag=1;
index d05f423..89c67f6 100644 (file)
 #include "Champ.h"
 #include "StringBox.h"
 #include "handleDrawing/drawTextEntity.h"
+#include "handleDrawing/drawFigureEntity.h"
+#include "handleDrawing/drawSubWinEntity.h"
+#include "handleDrawing/drawCompoundEntity.h"
+#include "handleDrawing/drawLegendEntity.h"
+#include "handleDrawing/drawFecEntity.h"
+#include "handleDrawing/drawSegsEntity.h"
+#include "handleDrawing/drawGrayplotEntity.h"
+#include "handleDrawing/drawPolylineEntity.h"
+#include "handleDrawing/drawArcEntity.h"
+#include "handleDrawing/drawRectangleEntity.h"
+#include "handleDrawing/drawAxesEntity.h"
+#include "handleDrawing/drawMergeEntity.h"
+#include "handleDrawing/drawSurfaceEntity.h"
 #include "periScreen.h" /* to be removed */
+#include "PloEch.h"
+#include "axesScale.h"
 
 #include "math_graphics.h"
 #include "graphicSession.h"
 #include "Format.h"
+#include "axesScale.h"
+#include "drawMarks.h"
 
 #include "MALLOC.h" /* MALLOC */
 
@@ -49,33 +66,16 @@ extern HDC TryToGetDC(HWND hWnd);
 
 #define                round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
 
-extern int GetScreenDPI(int *ixres, int *iyres);
-int WindowsPrintScreen = 0;
-int Printer_XRes = 0;
-int Printer_YRes = 0;
-
 extern double C2F(dsort)();/*DJ.A merge*/ 
 extern int scilab_shade(integer *polyx, integer *polyy, integer *fill, integer polysize, integer flag);
 extern void xstringb_angle (char *string, integer x, integer y, integer w, integer h, double angle);
 extern void xstringb_bbox (char *string, integer x, integer y, integer w, integer h, double angle, int *bbox);
-extern int GlobalFlag_Zoom3dOn;
 #ifdef _MSC_VER
 extern void Scistring (char *str);
 #endif
 
-extern int index_vertex;
-int Store3DPixelValues(sciPointObj * pobj, int xm, int ym, double x, double y, double z);
-static Vertices * pHead = (Vertices *) NULL;
-static Vertices * pHead2 = (Vertices *) NULL;
-
 void GradFixedlog( double minVal, double maxVal, double * ticks, int nbGrads );
 int sciGetLogExponent( double minBound, double maxBound, double * expMin, double * expMax );
-void retrieveFacetVertices( sciPointObj *  pobj, int facetIndex, double verticesX[], double verticesY[],double verticesZ[],double ** zOriginal);
-
-
-static double xz1,yz1;
-#define TX3D(x1,y1,z1) inint(xz1= Cscale.Wscx1*(TRX(x1,y1,z1)-Cscale.frect[0]) +Cscale.Wxofset1);
-#define TY3D(x1,y1,z1) inint(yz1= Cscale.Wscy1*(-TRY(x1,y1,z1)+Cscale.frect[3])+Cscale.Wyofset1);
 
 unsigned short defcolors[] = {
   0,   0,   0, /* Black: DEFAULTBLACK */
@@ -414,164 +414,6 @@ void updateScale3d( sciPointObj * pobj    ,
   }
 }
 
-/**axis_3ddraw 10/2003
- * @author Djalel Abdemouche
- * Should be in Axes.c file
- */
-void axis_3ddraw(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD) 
-{
-  double dbox[6];
-  integer flag,i,p,n,pat,hiddencolor, x[5]; /* F. Leray : redimmensionnment (+1) du tableau x[4];*/
-  static double Alpha, Teta;
-  int verbose=0,narg;
-  integer ixbox[8],iybox[8],xind[8],dash[6];
-  integer background,zero=0, color_old; /* Adding color_old 04.03.04*/
-  sciSubWindow * ppsubwin =  pSUBWIN_FEATURE (pobj);
-  EAxesBoxType subWinBoxType = sciGetBoxType( pobj ) ;
-
-  /* Initialisation phase for x (to detect bug): x set to -1000 F.Leray 05.03.04*/
-  for(i=0;i<5;i++) { x[i] = -1000 ; }
-
-  if(sciGetEntityType (pobj) == SCI_SUBWIN)
-    {  
-      
-      updateScale3d( pobj, dbox, xbox, ybox, zbox ) ;
-      /* Until here we have computed + reset the 3d scale*/
-      Teta  = ppsubwin->theta  ;
-      Alpha =  ppsubwin->alpha ;
-      if( Abs( Teta ) < 0.1 )
-      {
-       /* to avoid bug at limit when theta == 0 */
-       /* I recompute temp value xyzbox with theta == 0.1 */
-       /* to have a correct xind, InsideU et InsideD */
-       ComputeCorrectXindAndInsideUD( Teta, Alpha, dbox, xind, InsideU, InsideD ) ;
-      }
-      else
-      {
-        sciAxesVerticesIndices( InsideU, InsideD, xbox, ybox, xind ) ;
-      }
-
-      /* F.Leray Rajout 02.04.04 :*/
-      background = sciGetBackground(pobj) ;
-         
-      for ( i = 0 ; i < 6 ; i++ )
-      {
-        ixbox[i]=XScale(xbox[xind[i]]);
-        iybox[i]=YScale(ybox[xind[i]]);
-      }
-      ixbox[6] = ixbox[0] ;
-      iybox[6] = iybox[0] ;
-      p = 7 ;
-      n = 1 ; 
-      
-      C2F(dr)("xget","pattern",&verbose,&color_old,&zero,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      C2F(dr)("xset","pattern",&background,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
-      C2F (dr) ("xarea", "v", &p, ixbox, iybox, &n, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
-      C2F(dr)("xset","pattern",&color_old,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      /***********/
-      /***  hidden axis */
-
-      flag = ppsubwin->axes.flag[2]; /* box drawing */
-      
-      if ( subWinBoxType != BT_OFF )
-      { 
-        x[2] = sciGetLineWidth (pobj);
-        x[3] = sciGetLineStyle (pobj);
-        C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-          
-        hiddencolor = sciSetGoodIndex( pobj, ppsubwin->axes.hiddenAxisColor ) ;
-         
-       if (zbox[InsideU[0]] > zbox[InsideD[0]])
-        {
-         DrawAxis(xbox,ybox,InsideD,hiddencolor);
-        }       
-        else
-        {
-         DrawAxis(xbox,ybox,InsideU,hiddencolor);      
-       }
-       if (Ishidden(pobj))
-        {
-         ppsubwin->hiddenstate=(InsideU[0] % 4);
-        }
-       else
-        {
-         ppsubwin->hiddenstate=(InsideD[0] % 4);
-       }
-      }
-      /**  l'enveloppe cvxe*/
-      x[0] = sciGetForeground (pobj);   /* F.Leray 05.03.04 Useless or not?? because we used set pattern instead of set foreground (because Windows uses BRUSH and PEN...)*/
-      /* Wrong explanation: We use sciGetForeground in NG mode and used set foreground in old graphic mode*/
-      x[2] = sciGetLineWidth (pobj); /* Adding this line 05.03.04*/
-      x[3] = sciGetLineStyle (pobj);
-      x[4] = 0; 
-      C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
-      C2F(dr)("xget","pattern",&verbose,&pat,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      /* We are in axis_3ddraw() and sciGetEntityType (pobj) == SCI_SUBWIN*/
-      C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4,PI0,PD0,PD0,PD0,PD0, 5L, 6L);
-      C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,PI0,PD0,PD0,PD0,PD0,5L,4096); /* F.Leray 05.03.04 Useless too*/
-      C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      C2F (dr) ("xset", "line style", x+3,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-
-      p = 7 ;
-      n = 1 ;
-      for ( i = 0 ; i < p ; i++ )
-      {
-        ixbox[i] = XScale( xbox[ xind[i] ] ) ;
-        iybox[i] = YScale( ybox[ xind[i] ] ) ;
-      }
-      ixbox[p-1]=ixbox[0];iybox[p-1]=iybox[0]; 
-
-      if ( subWinBoxType == BT_BACK_HALF || subWinBoxType == BT_ON )
-      {
-        C2F(dr)("xpolys","v",ixbox,iybox,x,&n,&p,PI0,PD0,PD0,PD0,PD0,0L,0L);
-        
-      }
-      Axes3dStrings2(ixbox,iybox,xind) ;
-      
-      C2F(dr)("xset","pattern",&pat,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-    }
-}
-
-void triedre(sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD)
-{
-  integer  x[5],narg = 0;
-  integer color_kp,verbose = 0,thick_kp ;
-  integer style_kp[3] ;
-
-  C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray Replacement*/
-  C2F(dr)("xget","thickness",&verbose,&thick_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray addings here*/
-  C2F(dr)("xget","line style",&verbose,style_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray addings here*/
-
-  if(sciGetEntityType (pobj) == SCI_SUBWIN)
-  {
-    if(pSUBWIN_FEATURE (pobj)->axes.rect == BT_ON)
-    {
-      x[0] = sciGetForeground (pobj);  
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = sciGetLineStyle (pobj);
-      x[4] = 0;
-      
-      /* C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,PI0,PD0,PD0,PD0,PD0,5L,4096);*/
-      C2F(dr)("xset","pattern",x,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
-      C2F(dr)("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      C2F(dr)("xset", "line style", x+3,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      
-      if (zbox[InsideU[0]] > zbox[InsideD[0]])
-      {
-        DrawAxis(xbox,ybox,InsideU,x[0]);
-      }
-      else
-      {
-        DrawAxis(xbox,ybox,InsideD,x[0]);
-      }
-    }
-  }
-  C2F(dr)("xset", "line style",&(style_kp[0]),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);/*F.Leray addings here*/
-  C2F(dr)("xset","thickness",&thick_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);/*F.Leray addings here*/
-  C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /*F.Leray addings here*/
-  
-}
 
 /**Nextind
  * @author Djalel Abdemouche 10/2003
@@ -704,7 +546,7 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
       computeLabelAutoPos( ppsubwin->mon_title, segmentStart, segmentEnd, constOffset ) ;
     }
     /* draw the label */
-    drawText( ppLabel->text ) ;
+    drawTextEntity( ppLabel->text ) ;
   }
   
   textcolor = textcolor_old;
@@ -1284,7 +1126,7 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
         computeLabelAutoPos( ppsubwin->mon_z_label, segmentStart, segmentEnd, offset ) ;
       }
       /* a trick to force the display with 2d scale */
-      drawText( ppLabel->text ) ;
+      drawTextEntity( ppLabel->text ) ;
       
     }
   
@@ -1851,7 +1693,7 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
           computeLabelAutoPos( ppsubwin->mon_x_label, segmentStart, segmentEnd, offset ) ;
         }
         /* a trick to force the display with 2d scale */
-        drawText( ppLabel->text ) ;
+        drawTextEntity( ppLabel->text ) ;
         
       }
     }
@@ -2405,7 +2247,7 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
           computeLabelAutoPos( ppsubwin->mon_y_label, segmentStart, segmentEnd, offset ) ;
         }
         /* a trick to force the display with 2d scale */
-        drawText( ppLabel->text ) ;
+        drawTextEntity( ppLabel->text ) ;
         
       }
     }
@@ -2953,7 +2795,7 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
              computeLabelAutoPos( ppsubwin->mon_x_label, segmentStart, segmentEnd, offset ) ;
            }
            /* a trick to force the display with 2d scale */
-           drawText( ppLabel->text ) ;
+           drawTextEntity( ppLabel->text ) ;
            
        }
     }
@@ -3494,7 +3336,7 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
           computeLabelAutoPos( ppsubwin->mon_y_label, segmentStart, segmentEnd, offset ) ;
         }
         /* a trick to force the display with 2d scale */
-        drawText( ppLabel->text ) ;
+        drawTextEntity( ppLabel->text ) ;
         
       }
     }
@@ -3521,201 +3363,6 @@ int Axes3dStrings2(integer *ixbox, integer *iybox, integer *xind)
 
 
 
-int trans3d(sciPointObj *pobj,integer n,integer *xm,integer *ym,double *x, double *y,double *z)
-{
-  integer i;
-  double tmpx,tmpy,tmpz;
-  double  tmpx1,tmpy1,tmpz1;
-  /* TEST F.Leray 20.04.04: I fix HERE temporarily BOOL cube_scaling = FALSE; */
-  BOOL cube_scaling;
-  /* Test to enable reverse axis in 3D */ /* F.Leray 14.10.04 */
-  /*   int u; */
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(pobj);
-  /*  double xmin = Mini(x,n); */
-  /*   double xmax = Maxi(x,n); */
-
-  /*   double xmoy = (xmax+xmin)/2; */
-  
-  /*   double xmoy = (ppsubwin->FRect[0] + ppsubwin->FRect[2])/2; */
-  
-  double *xtmp = NULL;
-  double *ytmp = NULL;
-  
-  xtmp = MALLOC(n*sizeof(double));
-  ytmp = MALLOC(n*sizeof(double));
-
-
-    
-  if (sciGetEntityType(pobj) == SCI_SUBWIN){
-
-    cube_scaling = pSUBWIN_FEATURE(pobj)->cube_scaling;
-
-    if(cube_scaling == FALSE)
-      {
-       if (z == (double *) NULL)
-         for ( i=0 ; i < n ; i++)
-           {
-             /* F.Leray 19.10.04 */
-             /* Test to export logscale in 3D */
-
-             if(ppsubwin->logflags[0] == 'l')
-               tmpx = log10(x[i]);
-             else
-               tmpx = x[i];
-             
-             if(ppsubwin->logflags[1] == 'l')
-               tmpy = log10(y[i]);
-             else
-               tmpy = y[i];
-
-             if(ppsubwin->logflags[2] == 'l'){
-               sciprint("Warning: Value on z data is negative or zero while logarithmic scale enabled\n");
-               sciprint("Object not drawn\n");
-               FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-               return 0;
-             }
-
-             xm[i]= TX3D(tmpx,tmpy,0.0);
-             ym[i]= TY3D(tmpx,tmpy,0.0);
-             
-             if(GlobalFlag_Zoom3dOn==1)
-               Store3DPixelValues(pobj,xm[i],ym[i],tmpx,tmpy,0.); /* stockage des xm, ym pour le zoom */
-       
-             if ( finite(xz1)==0||finite(yz1)==0 ){
-               FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-               return(0);
-             }
-           }
-       else /* z != NULL */
-         for ( i=0 ; i < n ; i++) /* cas 3d le + general */
-           {
-
-             /* F.Leray 19.10.04 */
-             /* Test to export logscale in 3D */
-
-             if(ppsubwin->logflags[0] == 'l')
-               tmpx = log10(x[i]);
-             else
-               tmpx = x[i];
-             
-             if(ppsubwin->logflags[1] == 'l')
-               tmpy = log10(y[i]);
-             else
-               tmpy = y[i];
-
-             if(ppsubwin->logflags[2] == 'l')
-               tmpz = log10(z[i]);
-             else
-               tmpz = z[i];
-
-             xm[i]= TX3D(tmpx,tmpy,tmpz);
-             ym[i]= TY3D(tmpx,tmpy,tmpz);
-             
-             if(GlobalFlag_Zoom3dOn==1)
-               Store3DPixelValues(pobj,xm[i],ym[i],tmpx,tmpy,tmpz); /* stockage des xm, ym pour le zoom */
-             
-             if ( finite(xz1)==0||finite(yz1)==0 ){
-               FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-               return(0);
-             }
-             /*        } */
-           }
-       FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-      }
-    else   /* cube_scaling == TRUE now */
-      {
-       if (z == (double *) NULL)
-         for ( i=0 ; i < n ; i++)
-           {
-             
-             /* F.Leray 03.11.04 */
-             /* Test to export logscale in 3D */
-             
-             if(ppsubwin->logflags[0] == 'l')
-               tmpx = log10(x[i]);
-             else
-               tmpx = x[i];
-             
-             if(ppsubwin->logflags[1] == 'l')
-               tmpy = log10(y[i]);
-             else
-               tmpy = y[i];
-             
-             if(ppsubwin->logflags[2] == 'l'){
-               sciprint("Warning: Value on z data is negative or zero while logarithmic scale enabled\n");
-               sciprint("Object not drawn\n");
-               FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-               return 0;
-             }
-            
-             tmpx1 = tmpx;
-             tmpy1 = tmpy;
-             tmpz1 = 0.;
-
-             tmpx=(tmpx-pSUBWIN_FEATURE (pobj)->FRect[0])/(pSUBWIN_FEATURE (pobj)->FRect[2]-pSUBWIN_FEATURE (pobj)->FRect[0]);
-             tmpy=(tmpy-pSUBWIN_FEATURE (pobj)->FRect[1])/(pSUBWIN_FEATURE (pobj)->FRect[3]-pSUBWIN_FEATURE (pobj)->FRect[1]);
-             tmpz=(0.-pSUBWIN_FEATURE (pobj)->FRect[4])/(pSUBWIN_FEATURE (pobj)->FRect[5]-pSUBWIN_FEATURE (pobj)->FRect[4]); /* Adding F.Leray 04.11.04 */
-
-             xm[i]= TX3D(tmpx,tmpy,tmpz);
-             ym[i]= TY3D(tmpx,tmpy,tmpz);
-
-             if(GlobalFlag_Zoom3dOn==1)
-               Store3DPixelValues(pobj,xm[i],ym[i],tmpx1,tmpy1,tmpz1); /* stockage des xm, ym pour le zoom */
-            
-             if ( finite(xz1)==0||finite(yz1)==0 ){
-               FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-               return(0);
-             }
-           }
-       else /* z != NULL */
-         for ( i=0 ; i < n ; i++)
-           {
-
-             /* F.Leray 03.11.04 */
-             /* Test to export logscale in 3D */
-             
-             if(ppsubwin->logflags[0] == 'l')
-               tmpx = log10(x[i]);
-             else
-               tmpx = x[i];
-             
-             if(ppsubwin->logflags[1] == 'l')
-               tmpy = log10(y[i]);
-             else
-               tmpy = y[i];
-
-             if(ppsubwin->logflags[2] == 'l')
-               tmpz = log10(z[i]);
-             else
-               tmpz = z[i];
-            
-             tmpx1 = tmpx;
-             tmpy1 = tmpy;
-             tmpz1 = tmpz;
-
-             tmpx= (tmpx-pSUBWIN_FEATURE (pobj)->FRect[0])/(pSUBWIN_FEATURE (pobj)->FRect[2]-pSUBWIN_FEATURE (pobj)->FRect[0]);
-             tmpy= (tmpy-pSUBWIN_FEATURE (pobj)->FRect[1])/(pSUBWIN_FEATURE (pobj)->FRect[3]-pSUBWIN_FEATURE (pobj)->FRect[1]);
-             tmpz= (tmpz-pSUBWIN_FEATURE (pobj)->FRect[4])/(pSUBWIN_FEATURE (pobj)->FRect[5]-pSUBWIN_FEATURE (pobj)->FRect[4]); /* Adding F.Leray 28.04.04 */
-
-             xm[i]= TX3D(tmpx,tmpy,tmpz);
-             ym[i]= TY3D(tmpx,tmpy,tmpz);
-                 
-             if(GlobalFlag_Zoom3dOn==1)
-               Store3DPixelValues(pobj,xm[i],ym[i],tmpx1,tmpy1,tmpz1); /* stockage des xm, ym pour le zoom */
-          
-             /*    xm[i]= TX3D(tmpx,tmpy,tmpz); */
-             /*              ym[i]= TY3D(tmpx,tmpy,tmpz); */
-             if ( finite(xz1)==0||finite(yz1)==0 ){
-               FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-               return(0);
-             }
-           }
-      }
-    FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-  }
-  FREE(xtmp); xtmp = NULL; FREE(ytmp); ytmp = NULL;
-  return(1);
-}
 
 BOOL Ishidden(sciPointObj *pobj)
 {
@@ -3764,93 +3411,6 @@ BOOL IsDownAxes(sciPointObj *pobj)
   }
   return FALSE;
 }
-void Plo2dTo3d(integer type, integer *n1, integer *n2, double *x, double *y, double *z, double *x1, double *y1, double *z1)
-{
-  integer i,j;
-  switch (type)
-    {
-    case 2:
-      /** Computing y/z-values **/
-      for ( i=0 ; i < (*n2) ; i++)
-       for (j=0 ; j< (*n1) ; j++)
-         {
-           y1[2*i+1+2*(*n2)*j]= y1[2*i+2*(*n2)*j]= y[i+(*n2)*j];
-           if (z == NULL)
-             z1 = (double *) NULL;
-           else
-             z1[2*i+1+2*(*n2)*j]= z1[2*i+2*(*n2)*j]= z[i+(*n2)*j];
-         }
-      /*ym[2*i+1+2*(*n2)*j]= ym[2*i+2*(*n2)*j]= YScale(y[i+(*n2)*j]);*/
-     
-      /** Computing x-values **/
-      for (j=0 ; j< (*n1) ; j++)
-       {
-         for ( i=1 ; i < (*n2) ; i++)
-           {
-             x1[2*i+2*(*n2)*j]= x[i+(*n2)*j];
-             x1[2*i-1+2*(*n2)*j]=x1[2*i+2*(*n2)*j];
-           }
-         x1[2*(*n2)*j]= x[(*n2)*j];
-         x1[2*(*n2)-1+ 2*(*n2)*j]= x1[2*(*n2-1)+ 2*(*n2)*j];
-       }
-      break;
-    case 3:
-      /** Computing y-values **/
-      for ( i=0 ; i < (*n2) ; i++)
-       for (j=0 ; j< (*n1) ; j++)
-         {
-           y1[2*i+1+2*(*n2)*j]= 0.0;
-           y1[2*i+2*(*n2)*j]= y[i+(*n2)*j];
-         }
-      /** Computing x/z-values **/
-      for (j=0 ; j< (*n1) ; j++)
-       {
-         for ( i=0 ; i < (*n2) ; i++)
-           {
-             x1[2*i+2*(*n2)*j]= x[i+(*n2)*j];
-             x1[2*i+1+2*(*n2)*j]=x1[2*i+2*(*n2)*j]; 
-             if (z == NULL)
-               z1 = (double *) NULL;
-             else
-               {
-                 z1[2*i+2*(*n2)*j]= z[i+(*n2)*j];
-                 z1[2*i+1+2*(*n2)*j]=z1[2*i+2*(*n2)*j];
-               }
-           }
-       }
-      break;
-    case 4: 
-      /** Computing y-values **/
-      for ( i=0 ; i < (*n2) ; i++)
-       for (j=0 ; j< (*n1) ; j++)
-         y1[2*i+2*(*n2)*j]= y[i+(*n2)*j];
-      for ( i=0 ; i < (*n2)-1 ; i++)
-       for (j=0 ; j< (*n1) ; j++)
-         y1[2*i+1+2*(*n2)*j]=y1[2*i+2+2*(*n2)*j]; 
-      /** Computing x-values **/
-      for (j=0 ; j< (*n1) ; j++)
-       for ( i=0 ; i < (*n2) ; i++)
-         x1[2*i+2*(*n2)*j]= x[i+(*n2)*j];
-      for (j=0 ; j< (*n1) ; j++)
-       for ( i=0 ; i < (*n2)-1 ; i++)
-         x1[2*i+1+2*(*n2)*j]=x1[2*i+2+2*(*n2)*j];
-      /** Computing z-values **/
-      if (z == NULL)
-       z1 = (double *) NULL;
-      else
-       {
-         for (j=0 ; j< (*n1) ; j++)
-           for ( i=0 ; i < (*n2) ; i++)
-             z1[2*i+2*(*n2)*j]= z[i+(*n2)*j];
-         for (j=0 ; j< (*n1) ; j++)
-           for ( i=0 ; i < (*n2)-1 ; i++)
-             z1[2*i+1+2*(*n2)*j]=z1[2*i+2+2*(*n2)*j];
-       }
-      break;
-    default:
-      break;
-    } 
-}
 
 /* compute the graduation of the segment [minVal,maxVal] knowing the number of ticks */
 void GradFixedlog( double minVal, double maxVal, double * ticks, int nbGrads )
@@ -4031,7 +3591,7 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
   {
     if ( sciGetLogExponent( *xmin, *xmax, xmin, xmax ) != 0 )
     {
-      Scistring("Warning: Can't use Log on X-axis xmin is negative. \n");
+      sciprint("Warning: Can't use Log on X-axis xmin is negative. \n");
     }
   }
 
@@ -4042,7 +3602,7 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
   {
     if ( sciGetLogExponent( *ymin, *ymax, ymin, ymax ) != 0 )
     {
-      Scistring("Warning: Can't use Log on Y-axis ymin is negative. \n");
+      sciprint("Warning: Can't use Log on Y-axis ymin is negative. \n");
     }
   }
 
@@ -4053,7 +3613,7 @@ void sciGetDisplayedBounds( sciPointObj * pSubWin,
   {
     if ( sciGetLogExponent( *zmin, *zmax, zmin, zmax ) != 0 )
     {
-      Scistring("Warning: Can't use Log on Z-axis zmin is negative. \n");
+      sciprint("Warning: Can't use Log on Z-axis zmin is negative. \n");
     }
   }
 
@@ -4236,8 +3796,6 @@ BOOL sci_update_frame_bounds_3d(sciPointObj *pobj)
 {
   double xmin,xmax,ymin,ymax,zmin,zmax; 
   int i;
-  /*   double lmin,lmax; */
-  /*   integer min,max,puiss,deux=2,dix=10,n1,n2; */
   sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj); 
 
   /* Temp variables only used when called from update_specification_bounds */
@@ -4254,77 +3812,8 @@ BOOL sci_update_frame_bounds_3d(sciPointObj *pobj)
   nbgrads[0] = ppsubwin->axes.nxgrads;
   nbgrads[1] = ppsubwin->axes.nygrads;
   nbgrads[2] = ppsubwin->axes.nzgrads;
-  
-  /*****************************************************************
-   * get initial bounds
-   *****************************************************************/
-
- /*  if(sciGetZooming(pobj) == TRUE) { /\* a revoir *\/ */
-/*     xmin= ppsubwin->ZRect[0];  */
-/*     ymin= ppsubwin->ZRect[1];  */
-/*     xmax= ppsubwin->ZRect[2]; */
-/*     ymax= ppsubwin->ZRect[3]; */
-/*     zmin= ppsubwin->ZRect[4]; */
-/*     zmax= ppsubwin->ZRect[5]; */
-/*   } */
-/*   else { */
-/*     xmin=ppsubwin->SRect[0]; */
-/*     xmax=ppsubwin->SRect[1]; */
-/*     ymin=ppsubwin->SRect[2]; */
-/*     ymax=ppsubwin->SRect[3]; */
-/*     zmin=ppsubwin->SRect[4]; */
-/*     zmax=ppsubwin->SRect[5]; */
-/*   } */
-
- /*  ppsubwin->axes.limits[1]=xmin; /\* set a quoi?? au final ca saute normalement...*\/ */
-/*   ppsubwin->axes.limits[3]=xmax; /\* F.Leray 19.10.04 *\/ */
-/*   ppsubwin->axes.limits[2]=ymin; */
-/*   ppsubwin->axes.limits[4]=ymax; */
-/*   ppsubwin->axes.limits[5]=zmin; */
-/*   ppsubwin->axes.limits[6]=zmax; */
-
 
   sciGetDisplayedBounds( pobj, &xmin, &xmax, &ymin, &ymax, &zmin, &zmax ) ;
-
-  /* /\***************************************************************** */
-/*    * modify  bounds and aaint  if using log scaling X axis */
-/*    *****************************************************************\/ */
-/*   if ( ppsubwin->logflags[0]=='l') { */
-/*     if ( xmin >  0) { */
-/*       xmax=ceil(log10(xmax));  xmin=floor(log10(xmin)); */
-/*     } */
-/*     else { */
-/*       Scistring("Warning: Can't use Log on X-axis xmin is negative \n"); */
-/*       xmax= 1; xmin= 0; */
-/*     } */
-/*   } */
-  
-/*   /\***************************************************************** */
-/*    * modify  bounds and aaint  if using log scaling Y axis */
-/*    *****************************************************************\/ */
-/*   if ( ppsubwin->logflags[1]=='l') { */
-/*     if ( ymin > 0 ) { */
-/*       ymax= ceil(log10(ymax)); ymin= floor(log10(ymin)); */
-/*     } */
-/*     else { */
-/*       Scistring(" Can't use Log on Y-axis ymin is negative \n"); */
-/*       ymax= 1; ymin= 0; */
-/*     } */
-/*   } */
-  
-
-/*   /\***************************************************************** */
-/*    * modify  bounds and aaint  if using log scaling Y axis */
-/*    *****************************************************************\/ */
-/*   if ( ppsubwin->logflags[2]=='l') { */
-/*     if ( zmin > 0 ) { */
-/*       zmax= ceil(log10(zmax)); zmin= floor(log10(zmin)); */
-/*     } */
-/*     else { */
-/*       Scistring(" Can't use Log on Z-axis zmin is negative \n"); */
-/*       zmax= 1; zmin= 0; */
-/*     } */
-/*   } */
   
 
   /* _grad Init. to 0. */
@@ -4396,10 +3885,6 @@ BOOL sci_update_frame_bounds_3d(sciPointObj *pobj)
    
   set_scale("tftftf",NULL,ppsubwin->FRect,NULL,ppsubwin->logflags,NULL); 
      
-  /*   ppsubwin->axes.reverse[0] = FALSE; /\*TRUE;*\/ */
-  /*   ppsubwin->axes.reverse[1] = FALSE; /\*TRUE;*\/  */
-  /*   ppsubwin->axes.reverse[2] = FALSE; /\*TRUE;*\/  */
-     
   wininfo("alpha=%.1f,theta=%.1f",ppsubwin->alpha,ppsubwin->theta); 
     
   for(i=0;i<6;i++)
@@ -4423,5043 +3908,678 @@ BOOL sci_update_frame_bounds_3d(sciPointObj *pobj)
 
 
 
-/* F.Leray 07.05.04 */
-/* This routine rebuild a needed strflag for axis_draw call in sciDrawObj*/
-/* It may be less complete than the original strflag given in plot2dn (or other 2D - plot function)
-   due to less info. Nevertheless this new strflag is sufficient for axis_draw because
-   tests are on strflag[1] (case =='5' or '6') and strflag[2] */
-void rebuild_strflag( sciPointObj * psubwin, char * STRFLAG)
+
+
+
+
+int ComputeNbSubTics(sciPointObj * pobj, int nbtics, char logflag, double * grads, int nbsubtics_input)
 {
+  int ticsval[] =    {2 ,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+  int subticsval[] = {10,7,5,5,4,4,3,2,2 ,2 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 };
+  int i;
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
 
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  BOOL isaxes = GetIsAxes2D(psubwin);
 
-  /* strflag[0]*/
-  STRFLAG[0] = '0'; /* flag for caption display unused here so set to NULL by default */
-  if( pSUBWIN_FEATURE (psubwin)->with_leg == 1)
-    STRFLAG[0] = '0';
-  else
-    STRFLAG[0] = '1';
+  if(logflag =='l'){
+    if((grads[1]-grads[0])==1) /* intervalle de type ...10^n 10^(n+1)...*/
+      {
+       return 9; /* 9 subtics to have a pretty tics/grid in log.*/
+      }
+    else
+      {
+       return 1; /* no subtics at all (1 but draw on a tics place) */
+      }
+  }
+  else{
+    if(ppsubwin->flagNax == FALSE) /* if auto subtics mode == ON */
+      { 
+       for(i=0;i<19;i++)
+         if(nbtics == ticsval[i])
+           {
+             return subticsval[i];
+           }
+      }
+    else /* if auto subtics mode == OFF already computed in Plo2dn.c, Champ.c routines... */
+      {  /* or given via a.subtics=[nbsubtics_on_x, nbsubtics_on_y, nbsubtics_on_z] command */
+       return nbsubtics_input;
+      }
+  }
+  
+  return -1;
+}
 
-  /* strflag[1]*/
-  /* Here isoview mode test is not needed because axis_draw do not use it */
-  STRFLAG[1] = '0'; /* Init. to NULL <=> use the previous scale */
-  if(ppsubwin->tight_limits == TRUE)
-    {
-      STRFLAG[1] = '8';
-    }
-  else /* using auto rescale : enlarged for pretty axes*/
-    {
-      STRFLAG[1] = '6';
-    }
+/* test on x and y axes only : used in 2D routines only */
+BOOL GetIsAxes2D(sciPointObj *psubwin)
+{
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
   
-  /* strflag[2]*/
-  STRFLAG[2] = '1'; /* Init with y-axis on the left AND axes is on*/
-  if(isaxes == TRUE)
-    {
-      if(ppsubwin->axes.ydir =='l')
-       STRFLAG[2] = '1';
-      else if(ppsubwin->axes.ydir =='r')
-       STRFLAG[2] = '3';
-      else if((ppsubwin->axes.xdir =='c') && (ppsubwin->axes.ydir =='c'))
-       STRFLAG[2] = '5';
-    }
+  if((ppsubwin->axes.axes_visible[0] == FALSE)
+     && (ppsubwin->axes.axes_visible[1] == FALSE))
+    return FALSE;
   else
-    {
-      if(ppsubwin->axes.rect == BT_ON)
-       STRFLAG[2] = '2';
-      else
-       STRFLAG[2] = '0';
-    }
-  
-  STRFLAG[3] = '\0';
+    return TRUE;
 }
 
+int ComputeCorrectXindAndInsideUD(double Teta,double Alpha, double *dbox, integer *xind, integer *InsideU, integer *InsideD)
+{
+  double xbox[8], ybox[8], zbox[8];
+
+  Teta = 0.1; /* Little offset to compute correct values for xind,  InsideU and InsideD */
+
+  /* update Cscale.m from the new viewing angles */
+  sciUpdateScaleAngles( Teta, Alpha ) ;
+  sciGetAxisBox( dbox, xbox, ybox, zbox ) ;
+  sciAxesVerticesIndices( InsideU, InsideD, xbox, ybox, xind ) ;
+
+  return 0;
+}
 
-/*----------------------------------------------------------------------------------*/
-/* draw the title and the two labels of a 2d axis                                 */
-/*----------------------------------------------------------------------------------*/
-int labels2D_draw( sciPointObj * psubwin )
+/* don't waste time on %NaN */
+int CheckIfiisNan(int j, int dim, int * tab)
 {
-/* Rewritten by jb Silvy 06/2006 */
-  
-  integer rect1[4] ;
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
-  int offset[2] ; /* vertical and horizontal offsets to move labels a little from axes */
+  int i;
 
-  if ( !sciGetVisibility(psubwin) )
+  for(i=0;i<dim;i++)
   {
-    return 0 ;
+    if(tab[i] == j)
+      return -1;
   }
-  
-  /* get the size of the current subwin in pixels */
-  rect1[0]= Cscale.WIRect1[0] ; /* upper left point of the axes x coordinate. */
-  rect1[1]= Cscale.WIRect1[1] ; /* upper left point of the axes y coordinate. */
-  rect1[2]= Cscale.WIRect1[2] ; /* width of the axes */
-  rect1[3]= Cscale.WIRect1[3] ; /* height of the axes */
 
-  /* the little displacment of the labels from the axes box */
-  offset[0] = rect1[2] / 50 + 1 ;
-  offset[1] = rect1[3] / 25 + 1 ;
-  
+  return 0;
+}
+
+
+
+int ComputeGoodTrans3d( sciPointObj * psubwin, int n, int *xm, int *ym, double * fx, double *fy, double *fz)
+{
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
 
-  /*********/
-  /* TITLE */
-  /*********/
   
-  if ( sciGetVisibility(ppsubwin->mon_title) )
-  {
-    /* get the pointer on the title */
-    sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_title ) ;
-    
-    /* get position and orientation of the title */
-    if ( ppLabel->auto_rotation )
-    {
-      sciSetFontOrientation( ppsubwin->mon_title, 0 ) ;
-    }
-    
-    
-    if ( ppLabel->auto_position )
-    {
-      int segmentStart[2] = { rect1[0] + rect1[2], rect1[1] } ;
-      int segmentEnd[2]   = { rect1[0]           , rect1[1] } ;
-      computeLabelAutoPos( ppsubwin->mon_title, segmentStart, segmentEnd, offset ) ;
-    }
-    /* draw the label */
-    drawText( ppLabel->text ) ;
+  double tmp_fx = *fx;
+  double tmp_fy = *fy;
+  double tmp_fz = *fz;
+  
+  if(ppsubwin->logflags[0] == 'l')
+    tmp_fx = exp10(tmp_fx);
+  
+  if(ppsubwin->logflags[1] == 'l')
+    tmp_fy = exp10(tmp_fy);
+  
+  if(ppsubwin->logflags[2] == 'l')
+    tmp_fz = exp10(tmp_fz);
+  
+  trans3d(psubwin, n, xm, ym, &tmp_fx, &tmp_fy, &tmp_fz);
+  
+  return 0;
+}
 
+
+/**DrawAxesIfRequired
+ * Draws Axes (only the basic  graphicobject under subwindows) in its SubWindow or figure
+ * if and only if pFIGURE_FEATURE(pobj)->auto_redraw == TRUE !!
+ * Only used inside High Level functions calls (sucha as plot2d, plot3d...)
+ * @param sciPointObj * pobj: the pointer to the entity
+ * @return  int 0 if OK, -1 if not
+ */
+void DrawAxesIfRequired(sciPointObj * pobj)
+{
+  sciPointObj * pfigure = sciGetParentFigure(pobj);
+  
+  if( pFIGURE_FEATURE(pfigure)->auto_redraw && pFIGURE_FEATURE(pfigure)->visible )
+  {
+    DrawAxes(pobj);
   }
   
-  /***********/
-  /* x label */
-  /***********/
+}
+
+/* Routine used inside Plo2dn.c, Champ.c, Gray.c... */
+/* to force the drawing of the axes after a new object is created */
+void DrawAxes(sciPointObj * pobj)
+{
+  sciPointObj * psubwin = sciGetParentSubwin(pobj);
+  /*   sciPointObj * pfigure = sciGetParentFigure(pobj); */
+  char STRFLAG[4];
+  integer x[6], v, markidsizenew[2];
+  double dv;
+
+  if (!sciGetVisibility(pobj)) return;
   
-  if( sciGetVisibility(ppsubwin->mon_x_label) )
-  {
-    /* get the pointer on the title */
-    sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_x_label ) ;
-    
-    if( ppLabel->auto_rotation )
+  x[0] = sciGetForeground (psubwin);
+  x[2] = sciGetLineWidth (psubwin);
+  x[3] = sciGetLineStyle (psubwin);
+  markidsizenew[0] = sciGetMarkStyle(psubwin);
+  markidsizenew[1] = sciGetLineWidth (psubwin);
+  x[4] = 0;
+  v = 0;
+  dv = 0;
+
+  
+  sciSetSelectedSubWin(psubwin); 
+  
+  set_scale ("tttftt", pSUBWIN_FEATURE (psubwin)->WRect, pSUBWIN_FEATURE (psubwin)->FRect,
+            NULL, pSUBWIN_FEATURE (psubwin)->logflags, 
+            pSUBWIN_FEATURE (psubwin)->ARect); 
+     
+  if (!pSUBWIN_FEATURE (psubwin)->is3d)   /* we are in 2D mode...*/
     {
-      sciSetFontOrientation(ppsubwin->mon_x_label, 0 ) ;
+      /* F.Leray 07.12.04 */
+      /* TO CORRECT the bug 1115 : Big object (grayplots) could cover axes*/
+      C2F (dr) ("xset","dashes",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
+      C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
+      C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+      C2F (dr) ("xset","mark",&markidsizenew[0],&markidsizenew[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+
+      rebuild_strflag(psubwin,STRFLAG);
+      axis_draw2 (STRFLAG); /* Axes is rebuilt here to avoid being covered by the new created object */
     }
+}
 
-    
-    if( ppLabel->auto_position )
-    {
-      int segmentStart[2] ;
-      int segmentEnd[2]   ;
 
-      if(ppsubwin->axes.xdir == 'u')
-      {
-        segmentStart[0] = rect1[0] + rect1[2] ;
-        segmentEnd[0]   = rect1[0] ;
+/* Used only when switching from a plot3d to a plot2d or 
+ * when typing: a=gca();
+ *              a.view='2d' and we were in 3d 
+ * to have a good update of 3d graphics scale in 2D
+ * whenever we are in auto_redraw OFF  */
+void UpdateSubwinScale(sciPointObj * pobj)
+{
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
+  sciPointObj * currentsubwin = NULL;
+  BOOL vis_save = FALSE;
+  double xbox[8],ybox[8],zbox[8];
+  static integer InsideU[4],InsideD[4];
+       
+  currentsubwin = (sciPointObj *)sciGetSelectedSubWin (sciGetCurrentFigure ());
 
-        /* we add the size of the numbers to the height */
-        segmentStart[1] = ppsubwin->XGradMostOnTop ;
-        segmentEnd[1]   = ppsubwin->XGradMostOnTop ;
+  sciSetSelectedSubWin(pobj); 
+  
+  /*   set_scale ("tttftt", pSUBWIN_FEATURE (pobj)->WRect, pSUBWIN_FEATURE (pobj)->FRect, */
+  /*        NULL, pSUBWIN_FEATURE (pobj)->logflags,  */
+  /*        pSUBWIN_FEATURE (pobj)->ARect);  */
+  
+  if (ppsubwin->is3d) 
+    {  /* 3D Coordinates */ /* verifier si c'est encore utile SS */
+      /*To have directly all the possible ISOVIEW Modes*/
+      long isoflag = (long)(ppsubwin->axes.flag[1]+1)/2; 
+      
+      if(ppsubwin->isoview == TRUE) {
+       if(isoflag ==2 || isoflag == 3){                }
+       else {
+         if((ppsubwin->axes.flag[1] == 0)
+            || (ppsubwin->axes.flag[1] == 2))
+           /* The default isoview mode is type=4 3d isometric bounds 
+              derived from the data, to similarily type=2  */
+           ppsubwin->axes.flag[1] = 4; 
+         else if(ppsubwin->axes.flag[1] == 1)
+           ppsubwin->axes.flag[1] = 3;
+       }
       }
-      else
-      {
-        segmentStart[0] = rect1[0] ;
-        segmentEnd[0]   = rect1[0] + rect1[2] ;
-        
-        segmentStart[1] = ppsubwin->XGradMostOnBottom ;
-        segmentEnd[1]   = ppsubwin->XGradMostOnBottom ;
+      else {
+       if((ppsubwin->axes.flag[1] == 3) 
+          || (ppsubwin->axes.flag[1] == 5))
+         ppsubwin->axes.flag[1] = 1; /* computed from ebox*/
+       else if((ppsubwin->axes.flag[1] == 4) 
+               || (ppsubwin->axes.flag[1] == 6))
+         /* The default NON-isoview mode is 2 computed from data*/
+         ppsubwin->axes.flag[1] = 2; 
       }
-      computeLabelAutoPos( ppsubwin->mon_x_label, segmentStart, segmentEnd, offset ) ;
+      
+
+      vis_save = sciGetVisibility(pobj);
+
+      sciSetVisibility(pobj,FALSE);
+      axis_3ddraw(pobj,xbox,ybox,zbox,InsideU,InsideD); /* TEST on sciGetVisibility inside */
+      /* because axis_3ddraw displays 3d axes BUT ALSO compute + reset the 3d scale BEFORE !! */
+      sciSetVisibility(pobj,vis_save);
+    }
+  else /* we are in 2D mode...*/
+    {
+      sci_update_frame_bounds_2d(pobj);
     }
 
-    drawText( ppLabel->text ) ;
-    
-  }
-  
-  
-  /***********/
-  /* y label */
-  /***********/
+  sciSetSelectedSubWin(currentsubwin); 
   
+}
 
-  if ( sciGetVisibility(ppsubwin->mon_y_label) )
-  {
-    sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_y_label ) ;
+int Gen3DPoints(integer type,integer *polyx, integer *polyy, integer *fill, integer whiteid, double zmin, double zmax, double *x, double *y, double *z, integer i, integer j, integer jj1, integer *p, integer dc, integer fg, sciPointObj * psurface)
+{
+  sciPointObj *pobj;
+  int facteur = 1;
 
-    if( ppLabel->auto_rotation )
+  sciPointObj *psubwin = sciGetSelectedSubWin (sciGetCurrentFigure ());
+  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
+  sciSurface * ppsurface = pSURFACE_FEATURE (psurface);
+  
+  pobj = sciGetSelectedSubWin (sciGetCurrentFigure ()); 
+  if (trans3d(pobj ,1, &(polyx[  5*jj1]),&(polyy[  5*jj1]),&(x[i]),&(y[j]),&(z[i+(*p)*j]))==0) return 0; 
+  if (trans3d(pobj ,1, &(polyx[1+  5*jj1]),&(polyy[1+  5*jj1]),&(x[i]),&(y[j+1]),&(z[i+(*p)*(j+1)]))==0) return 0; 
+  if (trans3d(pobj ,1, &(polyx[2+  5*jj1]),&(polyy[2+  5*jj1]),&(x[i+1]),&(y[j+1]),&(z[(i+1)+(*p)*(j+1)]))==0) return 0; 
+  if (trans3d(pobj ,1, &(polyx[3+  5*jj1]),&(polyy[3+  5*jj1]),&(x[i+1]),&(y[j]),&(z[(i+1)+(*p)*j]))==0) return 0;   
+  if (trans3d(pobj ,1, &(polyx[4+  5*jj1]),&(polyy[4+  5*jj1]),&(x[i]),&(y[j]),&(z[i+(*p)*j]))==0) return 0; 
+  
+  
+  if(ppsubwin->axes.reverse[0] == TRUE) facteur = -facteur;
+  if(ppsubwin->axes.reverse[1] == TRUE) facteur = -facteur;
+  if(ppsubwin->axes.reverse[2] == TRUE) facteur = -facteur;
+  
+  /* try */
+  facteur = ppsurface->flag_x * ppsurface->flag_y * facteur;
+  
+  /* type == flagcolor and dc == color_mode */
+  /* fg = hidden color */
+  
+  if ((((polyx[1+5*jj1]-polyx[0+5*jj1])*(polyy[2+5*jj1]-polyy[0+5*jj1])-
+       (polyy[1+5*jj1]-polyy[0+5*jj1])*(polyx[2+5*jj1]-polyx[0+5*jj1]))*facteur <  0) && (fg >=0 )) 
     {
-      sciInitFontOrientation( ppsubwin->mon_y_label, 270 * 10 ) ;
+      
+      /* ------------------- */
+      /* Beneath the surface */
+      /* ------------------- */
+
+      if (type != 0) /* flagcolor = 1 case : special treatment compared to flagcolor = 0 */
+                    /* don't know why... F.Leray */
+       fill[jj1]= (dc < 0 ) ? -fg : fg ;
+      else           /* flagcolor = 0 :  No shading at all, fixed facecolor. */
+       fill[jj1]=  (dc != 0 ) ? fg : dc ;
     }
-    
-    if( ppLabel->auto_position )
+  else
     {
-      int segmentStart[2] ;
-      int segmentEnd[2]   ;
-
-      if(ppsubwin->axes.ydir == 'r')
-      {
 
-         /* we add the size of the numbers to the height */
-        segmentStart[0] = ppsubwin->YGradMostOnRight ;
-        segmentEnd[0]   = ppsubwin->YGradMostOnRight ;
+      /* ------------------- */
+      /* Above the surface */
+      /* ------------------- */
 
-        segmentStart[1] = rect1[1] + rect1[3] ;
-        segmentEnd[1]   = rect1[1] ;
-      }
+     if (type != 0)
+       {  /* flagcolor = 1 :  Z-level flat shading. */
+         fill[jj1]=inint((whiteid-1)*((1/4.0*( z[i+(*p)*j]+ z[i+1+(*p)*j]+
+                                               z[i+(*p)*(j+1)]+ z[i+1+(*p)*(j+1)])-zmin)
+                                      /(zmax-zmin)))+1;
+         if ( dc < 0 ) fill[jj1]= -fill[jj1];  
+       }
       else
-      {
-        segmentStart[0] = ppsubwin->YGradMostOnLeft ;
-        segmentEnd[0]   = ppsubwin->YGradMostOnLeft ;
-        
-        segmentStart[1] = rect1[1] ;
-        segmentEnd[1]   = rect1[1] + rect1[3] ;
-      }
-      computeLabelAutoPos( ppsubwin->mon_y_label, segmentStart, segmentEnd, offset ) ;
+       fill[jj1]= dc;     
     }
-    drawText( ppLabel->text ) ;
-  }
   
-  return 0;
+  return(1);
+  
 }
 
 
 
-
-int ComputeNbSubTics(sciPointObj * pobj, int nbtics, char logflag, double * grads, int nbsubtics_input)
+int Merge3dDimension(sciPointObj *pparent)
 {
-  int ticsval[] =    {2 ,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
-  int subticsval[] = {10,7,5,5,4,4,3,2,2 ,2 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 };
-  int i;
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
+  integer N,q; 
+  sciSons *psonstmp;
 
+  /* ========================================================================
+   * Compute the number of facets, segments,... included in all the subwin 
+   * children
+   * Each entities to merge; is decomposed in a set of basic elements 
+   *  (facet, segment, point,...)
+   * Each basic element is represented in the Merge structure by the handle of its entity and an 
+   *   index within this entity
+   * ========================================================================*/
 
-  if(logflag =='l'){
-    if((grads[1]-grads[0])==1) /* intervalle de type ...10^n 10^(n+1)...*/
-      {
-       return 9; /* 9 subtics to have a pretty tics/grid in log.*/
-      }
-    else
+  q=0;
+  psonstmp = sciGetSons (pparent);
+  while (psonstmp != (sciSons *) NULL) {   
+    switch (sciGetEntityType (psonstmp->pointobj)) {  
+    case SCI_SURFACE:
+      if (pSURFACE_FEATURE (psonstmp->pointobj)->typeof3d == SCI_PLOT3D) 
+       N=(pSURFACE_FEATURE (psonstmp->pointobj)->dimzx-1)*(pSURFACE_FEATURE (psonstmp->pointobj)->dimzy-1);
+      else
+       N = pSURFACE_FEATURE (psonstmp->pointobj)->dimzy;
+      break;
+
+    case  SCI_POLYLINE:
       {
-       return 1; /* no subtics at all (1 but draw on a tics place) */
-      }
-  }
-  else{
-    if(ppsubwin->flagNax == FALSE) /* if auto subtics mode == ON */
-      { 
-       for(i=0;i<19;i++)
-         if(nbtics == ticsval[i])
-           {
-             return subticsval[i];
-           }
-      }
-    else /* if auto subtics mode == OFF already computed in Plo2dn.c, Champ.c routines... */
-      {  /* or given via a.subtics=[nbsubtics_on_x, nbsubtics_on_y, nbsubtics_on_z] command */
-       return nbsubtics_input;
-      }
-  }
-  
-  return -1;
-}
-
-/* test on x and y axes only : used in 2D routines only */
-BOOL GetIsAxes2D(sciPointObj *psubwin)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
-  
-  if((ppsubwin->axes.axes_visible[0] == FALSE)
-     && (ppsubwin->axes.axes_visible[1] == FALSE))
-    return FALSE;
-  else
-    return TRUE;
-}
-
-int ComputeCorrectXindAndInsideUD(double Teta,double Alpha, double *dbox, integer *xind, integer *InsideU, integer *InsideD)
-{
-  double xbox[8], ybox[8], zbox[8];
-
-  Teta = 0.1; /* Little offset to compute correct values for xind,  InsideU and InsideD */
-
-  /* update Cscale.m from the new viewing angles */
-  sciUpdateScaleAngles( Teta, Alpha ) ;
-  sciGetAxisBox( dbox, xbox, ybox, zbox ) ;
-  sciAxesVerticesIndices( InsideU, InsideD, xbox, ybox, xind ) ;
-
-  return 0;
-}
-
-/* F.Leray 02.11.04 */
-/* BuildXYZvectForClipping_IfNanOrLogON : this function is used for polylines to determine if we have to cut the polyline data for 2 reasons: */
-/* - clipping is forced because we have a Nan inside the data columns */
-/* - clipping is forced because we have a log scale on an axis and polyline data < 0 on this axis (clipping on X11 or Win is based on pixel we compute so if */
-/* the algo tried to evaluate log(-5.6) (for example) and then we tried to make a Xscale (or logXscale) on it, it doesn't work at all!! */
-/* What we do is: we cut the polyline into several polylines and reject Nan values and data<0 if axis is in log scale */
-int  BuildXYZvectForClipping_IfNanOrLogON(sciPointObj *ppolyline, sciPointObj * psubwin, int * nb_curves, double *** xvect, double *** yvect, double *** zvect,int ** curves_size)
-{
-  int i,j,k;
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
-  sciPolyline * pppolyline = pPOLYLINE_FEATURE( ppolyline);
-  int *indexGoodPoints = NULL;
-  
-  int valeur = 0;
-  int nb = 0;
-  
-  int **store_data = (int **) NULL;
-  double * pvx_plus_x_shift = NULL;
-  double * pvy_plus_y_shift = NULL;
-  double * pvz_plus_z_shift = NULL;
-
-  double * x_shift = pppolyline->x_shift;
-  double * y_shift = pppolyline->y_shift;
-  double * z_shift = pppolyline->z_shift;
-  
-  if ( pppolyline->n1 == 0 )
-  {
-    *nb_curves   = 0    ;
-    *xvect       = NULL ;
-    *yvect       = NULL ;
-    *zvect       = NULL ;
-    *curves_size = 0    ;
-    return 0 ;
-  }
-
-  if ((pvx_plus_x_shift = MALLOC ((pppolyline->n1)*sizeof (double))) == NULL) return -1;
-  if(x_shift != (double *) NULL){ /* if shift is not NULL, its size is n1 */
-    for(i=0;i<pppolyline->n1;i++)
-      pvx_plus_x_shift[i] = pppolyline->pvx[i] + x_shift[i];
-  }
-  else{
-    for(i=0;i<pppolyline->n1;i++)
-      pvx_plus_x_shift[i] = pppolyline->pvx[i];
-  }
-  
-    
-  if ((pvy_plus_y_shift = MALLOC ((pppolyline->n1)*sizeof (double))) == NULL) return -1;
-  if(y_shift != (double *) NULL){ /* if shift is not NULL, its size is n1 */
-    for(i=0;i<pppolyline->n1;i++)
-      pvy_plus_y_shift[i] = pppolyline->pvy[i] + y_shift[i];
-  }
-  else{
-    for(i=0;i<pppolyline->n1;i++)
-      pvy_plus_y_shift[i] = pppolyline->pvy[i];
-  }
-    
-  
-  if(pppolyline->pvz != (double *) NULL || z_shift != (double *) NULL){
-    if ((pvz_plus_z_shift = MALLOC ((pppolyline->n1)*sizeof (double))) == NULL) return -1;
-
-    if(z_shift != (double *) NULL && pppolyline->pvz != (double *) NULL){ /* if shift is not NULL, its size is n1 */
-      for(i=0;i<pppolyline->n1;i++)
-       pvz_plus_z_shift[i] = pppolyline->pvz[i] + z_shift[i];
-    }
-    else if(z_shift != (double *) NULL && pppolyline->pvz == (double *) NULL){
-      for(i=0;i<pppolyline->n1;i++)
-       pvz_plus_z_shift[i] = z_shift[i];
-    }
-    else if(z_shift == (double *) NULL && pppolyline->pvz != (double *) NULL){
-      for(i=0;i<pppolyline->n1;i++)
-       pvz_plus_z_shift[i] = pppolyline->pvz[i];
-    }
-  }
-  
-
-  if ((store_data = (int **) MALLOC ((3)*sizeof (int *))) == NULL) return -1;
-  for(i=0;i<3;i++) 
-    if ((store_data[i] = MALLOC ((pppolyline->n1)*sizeof (int))) == NULL) return -1;
-  
-  if ((indexGoodPoints = MALLOC ((pppolyline->n1)*sizeof (integer))) == NULL) return -1;
-  for(i=0;i<pppolyline->n1;i++) indexGoodPoints[i] = pppolyline->n1 + 1000;
-  
-  /* ICI dans mon exemple plot2d indexGoodPoints[i] = 63+1 = 64 */
-  
-  /*  we search for != %nan */
-  for(i=0;i<pppolyline->n1;i++)
-    {
-      if (pvz_plus_z_shift == (double *) NULL)
-       {
-         if((finite(pvx_plus_x_shift[i]) == 1) &&
-            (finite(pvy_plus_y_shift[i]) == 1))
-           indexGoodPoints[i] = 1;  /* x and y are finite numbers */
-         else
-           indexGoodPoints[i] = -1;
-       } 
-      else
-       {
-         if((finite(pvx_plus_x_shift[i]) == 1) &&
-            (finite(pvy_plus_y_shift[i]) == 1) &&
-            (finite(pvz_plus_z_shift[i]) == 1))
-           indexGoodPoints[i] = 1;
-         else
-           indexGoodPoints[i] = -1;
-         
-       }
-    }
-  
-
-  /* we search for values <= 0 if log_flag */
-  for(i=0;i<pppolyline->n1;i++)
-  {
-    if(ppsubwin->logflags[0] == 'l')
-    {
-      if((indexGoodPoints[i] == 1) && (pvx_plus_x_shift[i] <= 0))
-        indexGoodPoints[i] = -1;
-    }
-      
-    if(ppsubwin->logflags[1] == 'l') 
-    {
-      if((indexGoodPoints[i] == 1) && (pvy_plus_y_shift[i] <= 0))
-        indexGoodPoints[i] = -1;
-    }
-      
-    if(pppolyline->pvz != NULL && ppsubwin->logflags[2] == 'l') 
-    {
-      if((indexGoodPoints[i] == 1) && (pvz_plus_z_shift[i] <= 0))
-        indexGoodPoints[i] = -1;
-    }
-      
-  }
-  
-  valeur = indexGoodPoints[0]; /* -1 ou 1 */
-  
-  
-  *nb_curves = 0;
-  if(valeur == 1){ /* we begin by a draw point/line */
-    *nb_curves = 0;
-    
-    j=0;
-    
-    while(j<pppolyline->n1)
-      {
-               
-       for(i=j;i<pppolyline->n1;i++)
-         if(indexGoodPoints[i] == 1)
-           continue;
-         else
-           break;
-
-       store_data[0][(*nb_curves)] = j;
-       store_data[1][(*nb_curves)] = i;
-       store_data[2][(*nb_curves)] = i-j;
-
-       *nb_curves = *nb_curves + 1; /* STOCKER AUSSI LES INDEXES EXTREMITES OU C'EST EGAL A  1 !! */
-       
-
-       for(k=i;k<pppolyline->n1;k++)
-         if(indexGoodPoints[k] == -1)
-           continue;
-         else
-           break;
-      
-       j=k;
-
-      }
-  }
-  else if(valeur == -1){/* we begin with a not drawn point/line */
-    *nb_curves = 0;
-    
-    j=0;
-    
-    while(j<pppolyline->n1)
-      {
-               
-       for(i=j;i<pppolyline->n1;i++)
-         if(indexGoodPoints[i] == -1)
-           continue;
-         else
-           break;
-
-       for(k=i;k<pppolyline->n1;k++)
-         if(indexGoodPoints[k] == 1)
-           continue;
-         else
-           break;
-
-       store_data[0][(*nb_curves)] = i;
-       store_data[1][(*nb_curves)] = k;
-       store_data[2][(*nb_curves)] = k-i;
-       
-
-       *nb_curves = *nb_curves + 1;
-       j=k;
-
-      }
-  }
-  else{
-    printf("Impossible case in CheckClippingNanLogON\n");
-  }
-  
-  
-  nb = *nb_curves;
-
-  /* XYZ vect building */
-  if (( (*xvect) = (double **) MALLOC ((nb)*sizeof (double *))) == NULL) return -1;
-  if (( (*yvect) = (double **) MALLOC ((nb)*sizeof (double *))) == NULL) return -1;
-  if (( (*zvect) = (double **) MALLOC ((nb)*sizeof (double *))) == NULL) return -1;
-    
-  for(i=0;i<nb;i++)
-    {
-      int cmpteur = 0;
-      /* Allocating arrays x, y and zvect */
-      if(store_data[2][i] > 0){
-       if (( (*xvect)[i] = (double *) MALLOC ((store_data[2][i])*sizeof (double))) == NULL) return -1;
-       if (( (*yvect)[i] = (double *) MALLOC ((store_data[2][i])*sizeof (double))) == NULL) return -1;
-       if(pvz_plus_z_shift == NULL)
-         (*zvect)[i] = NULL;
-       else
-         if (( (*zvect)[i] = (double *) MALLOC ((store_data[2][i])*sizeof (double))) == NULL) return -1;
-      }
-      for(j=store_data[0][i];j<store_data[1][i];j++)
-       {
-         (*xvect)[i][cmpteur] = pvx_plus_x_shift[j];
-         (*yvect)[i][cmpteur] = pvy_plus_y_shift[j];
-         if(pvz_plus_z_shift != NULL)
-           (*zvect)[i][cmpteur] = pvz_plus_z_shift[j];
-         
-         cmpteur++;
-         
-       }
-    }
-  
-  if (( (*curves_size) = (int *) MALLOC ((nb)*sizeof (int))) == NULL) return -1;
-  
-  for(i=0;i<nb;i++)
-    {
-      (*curves_size)[i] = store_data[2][i];
-    }
-  
-  
-  for(i=0;i<3;i++){
-    FREE(store_data[i]); 
-    store_data[i] = (int *) NULL;
-  }
-  
-  FREE(store_data); store_data = (int **) NULL;
-  FREE(indexGoodPoints); indexGoodPoints = (int *) NULL;
-  FREE(pvx_plus_x_shift); pvx_plus_x_shift = (double *) NULL;
-  FREE(pvy_plus_y_shift); pvy_plus_y_shift = (double *) NULL;
-  FREE(pvz_plus_z_shift); pvz_plus_z_shift = (double *) NULL;
-  return 0;
-}
-
-
-/* don't waste time on %NaN */
-int CheckIfiisNan(int j, int dim, int * tab)
-{
-  int i;
-  
-  for(i=0;i<dim;i++)
-    {
-      if(tab[i] == j)
-       return -1;
-    }
-  
-  return 0;
-}
-
-
-
-
-
-int ComputeGoodTrans3d( sciPointObj * psubwin, int n, int *xm, int *ym, double * fx, double *fy, double *fz)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-
-  
-  double tmp_fx = *fx;
-  double tmp_fy = *fy;
-  double tmp_fz = *fz;
-  
-  /*  if(ppsubwin->axes.reverse[0] == TRUE) */
-  /*     tmp_fx = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],tmp_fx); */
-  
-  /*   if(ppsubwin->axes.reverse[1] == TRUE) */
-  /*     tmp_fy = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],tmp_fy); */
-  
-  /*   if(ppsubwin->axes.reverse[2] == TRUE) */
-  /*     tmp_fz = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],tmp_fz); */
-  
-  if(ppsubwin->logflags[0] == 'l')
-    tmp_fx = exp10(tmp_fx);
-  
-  if(ppsubwin->logflags[1] == 'l')
-    tmp_fy = exp10(tmp_fy);
-  
-  if(ppsubwin->logflags[2] == 'l')
-    tmp_fz = exp10(tmp_fz);
-  
-  trans3d(psubwin, n, xm, ym, &tmp_fx, &tmp_fy, &tmp_fz);
-  
-  return 0;
-}
-
-
-double InvAxis(double min, double max, double u)
-{
-  return (u-min)/(max-min)*min + (u-max)/(min-max)*max;
-}
-
-
-int ReverseDataFor3DXonly(sciPointObj * psubwin, double * xvect, int n1)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  int cmp;
-
-  if(ppsubwin->axes.reverse[0] == TRUE){
-    /* agir sur x */
-    if(ppsubwin->logflags[0]=='l'){
-      for(cmp=0;cmp<n1;cmp++)
-       {
-         xvect[cmp] = log10(xvect[cmp]);
-         xvect[cmp] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xvect[cmp]);
-         xvect[cmp] = exp10(xvect[cmp]);
-       }
-    }
-    else
-      for(cmp=0;cmp<n1;cmp++) 
-       xvect[cmp] =  InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xvect[cmp]);
-  }
-  
-  return 0;
-}
-
-int ReverseDataFor3DYonly(sciPointObj * psubwin, double * yvect, int n1)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  int cmp;
-
-  if(ppsubwin->axes.reverse[1] == TRUE){
-    /* agir sur y */
-    if(ppsubwin->logflags[1]=='l'){
-      for(cmp=0;cmp<n1;cmp++)
-       {
-         yvect[cmp] = log10(yvect[cmp]);
-         yvect[cmp] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],yvect[cmp]);
-         yvect[cmp] = exp10(yvect[cmp]);
-       }
-    }
-    else
-      for(cmp=0;cmp<n1;cmp++)
-       yvect[cmp] =  InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],yvect[cmp]);
-  }
-    
-  return 0;
-}
-
-
-int ReverseDataFor3DZonly(sciPointObj * psubwin, double * zvect, int n1)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  int cmp;
-
-  if(zvect != NULL){
-    if(ppsubwin->axes.reverse[2] == TRUE){
-      /* agir sur z */
-      if(ppsubwin->logflags[2]=='l'){
-       for(cmp=0;cmp<n1;cmp++)
-         {
-           zvect[cmp] = log10(zvect[cmp]);
-           zvect[cmp] = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],zvect[cmp]);
-           zvect[cmp] = exp10(zvect[cmp]);
-         }
-      }
-      else
-       for(cmp=0;cmp<n1;cmp++)
-         zvect[cmp] =  InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],zvect[cmp]);
-    }
-  }
-  
-  return 0;
-}
-
-int ReverseDataFor3D(sciPointObj * psubwin, double * xvect, double * yvect, double * zvect, int n1)
-{
-  
-  ReverseDataFor3DXonly(psubwin, xvect, n1);
-  ReverseDataFor3DYonly(psubwin, yvect, n1);
-  ReverseDataFor3DZonly(psubwin, zvect, n1);
-  
-  return 0;
-}
-
-
-/**DrawAxesIfRequired
- * Draws Axes (only the basic  graphicobject under subwindows) in its SubWindow or figure
- * if and only if pFIGURE_FEATURE(pobj)->auto_redraw == TRUE !!
- * Only used inside High Level functions calls (sucha as plot2d, plot3d...)
- * @param sciPointObj * pobj: the pointer to the entity
- * @return  int 0 if OK, -1 if not
- */
-void DrawAxesIfRequired(sciPointObj * pobj)
-{
-  sciPointObj * pfigure = sciGetParentFigure(pobj);
-  
-  if( pFIGURE_FEATURE(pfigure)->auto_redraw && pFIGURE_FEATURE(pfigure)->visible )
-  {
-    DrawAxes(pobj);
-  }
-  
-}
-
-/* Routine used inside Plo2dn.c, Champ.c, Gray.c... */
-/* to force the drawing of the axes after a new object is created */
-void DrawAxes(sciPointObj * pobj)
-{
-  sciPointObj * psubwin = sciGetParentSubwin(pobj);
-  /*   sciPointObj * pfigure = sciGetParentFigure(pobj); */
-  char STRFLAG[4];
-  integer x[6], v, markidsizenew[2];
-  double dv;
-
-  if (!sciGetVisibility(pobj)) return;
-  
-  x[0] = sciGetForeground (psubwin);
-  x[2] = sciGetLineWidth (psubwin);
-  x[3] = sciGetLineStyle (psubwin);
-  markidsizenew[0] = sciGetMarkStyle(psubwin);
-  markidsizenew[1] = sciGetLineWidth (psubwin);
-  x[4] = 0;
-  v = 0;
-  dv = 0;
-
-  
-  sciSetSelectedSubWin(psubwin); 
-  
-  set_scale ("tttftt", pSUBWIN_FEATURE (psubwin)->WRect, pSUBWIN_FEATURE (psubwin)->FRect,
-            NULL, pSUBWIN_FEATURE (psubwin)->logflags, 
-            pSUBWIN_FEATURE (psubwin)->ARect); 
-     
-  if (!pSUBWIN_FEATURE (psubwin)->is3d)   /* we are in 2D mode...*/
-    {
-      /* F.Leray 07.12.04 */
-      /* TO CORRECT the bug 1115 : Big object (grayplots) could cover axes*/
-      C2F (dr) ("xset","dashes",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
-      C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
-      C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      C2F (dr) ("xset","mark",&markidsizenew[0],&markidsizenew[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-
-      rebuild_strflag(psubwin,STRFLAG);
-      axis_draw2 (STRFLAG); /* Axes is rebuilt here to avoid being covered by the new created object */
-    }
-}
-
-
-/* Used only when switching from a plot3d to a plot2d or 
- * when typing: a=gca();
- *              a.view='2d' and we were in 3d 
- * to have a good update of 3d graphics scale in 2D
- * whenever we are in auto_redraw OFF  */
-void UpdateSubwinScale(sciPointObj * pobj)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pobj);
-  sciPointObj * currentsubwin = NULL;
-  BOOL vis_save = FALSE;
-  double xbox[8],ybox[8],zbox[8];
-  static integer InsideU[4],InsideD[4];
-       
-  currentsubwin = (sciPointObj *)sciGetSelectedSubWin (sciGetCurrentFigure ());
-
-  sciSetSelectedSubWin(pobj); 
-  
-  /*   set_scale ("tttftt", pSUBWIN_FEATURE (pobj)->WRect, pSUBWIN_FEATURE (pobj)->FRect, */
-  /*        NULL, pSUBWIN_FEATURE (pobj)->logflags,  */
-  /*        pSUBWIN_FEATURE (pobj)->ARect);  */
-  
-  if (ppsubwin->is3d) 
-    {  /* 3D Coordinates */ /* verifier si c'est encore utile SS */
-      /*To have directly all the possible ISOVIEW Modes*/
-      long isoflag = (long)(ppsubwin->axes.flag[1]+1)/2; 
-      
-      if(ppsubwin->isoview == TRUE) {
-       if(isoflag ==2 || isoflag == 3){                }
-       else {
-         if((ppsubwin->axes.flag[1] == 0)
-            || (ppsubwin->axes.flag[1] == 2))
-           /* The default isoview mode is type=4 3d isometric bounds 
-              derived from the data, to similarily type=2  */
-           ppsubwin->axes.flag[1] = 4; 
-         else if(ppsubwin->axes.flag[1] == 1)
-           ppsubwin->axes.flag[1] = 3;
-       }
-      }
-      else {
-       if((ppsubwin->axes.flag[1] == 3) 
-          || (ppsubwin->axes.flag[1] == 5))
-         ppsubwin->axes.flag[1] = 1; /* computed from ebox*/
-       else if((ppsubwin->axes.flag[1] == 4) 
-               || (ppsubwin->axes.flag[1] == 6))
-         /* The default NON-isoview mode is 2 computed from data*/
-         ppsubwin->axes.flag[1] = 2; 
-      }
-      
-
-      vis_save = sciGetVisibility(pobj);
-
-      sciSetVisibility(pobj,FALSE);
-      axis_3ddraw(pobj,xbox,ybox,zbox,InsideU,InsideD); /* TEST on sciGetVisibility inside */
-      /* because axis_3ddraw displays 3d axes BUT ALSO compute + reset the 3d scale BEFORE !! */
-      sciSetVisibility(pobj,vis_save);
-    }
-  else /* we are in 2D mode...*/
-    {
-      sci_update_frame_bounds_2d(pobj);
-    }
-
-  sciSetSelectedSubWin(currentsubwin); 
-  
-}
-
-
-
-/**sciClip
- * Set the clipping rectangle 
- * @author Djalel ABDEMOUCHE
- * 29/11/2002
- */
-/* Note that clipping is not supported at all in 3D mode for now : */
-/* This assertion includes axes (in 3D), surfaces and parametric curves objects. */
-
-void
-sciClip (sciPointObj *pobj)
-{
-  int x,y,w,h; 
-  int value;
-  double *clip_region = NULL;
-  
-  sciPointObj * psubwin = sciGetParentSubwin(pobj);
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  
-  value = sciGetIsClipping(pobj);     /* clipping state */
-  
-  if(value == -1) return;
-  if(ppsubwin->is3d == TRUE) return; /* no clipping in 3d */
-  
-  clip_region = sciGetClipping(pobj); /* clipping region */
-  
-  
-  if(sciGetIsClipRegionValuated(pobj) == 0)
-    value = 0; /* we use the 'clipgrf' value instead */
-  
-  if (value == 0){
-    double clip[4];
-    double tmpx, tmpy, tmpw, tmph;
-    
-    tmpw = fabs(ppsubwin->FRect[2] - ppsubwin->FRect[0]);
-    tmph = fabs(ppsubwin->FRect[3] - ppsubwin->FRect[1]);
-    
-    tmpx = ppsubwin->FRect[0]; /* xmin */
-    tmpy = ppsubwin->FRect[3]; /* ymax */
-    
-    clip[0] = tmpx;
-    clip[1] = tmpy;
-    clip[2] = tmpw;
-    clip[3] = tmph;
-    
-    sciSetClipping(pobj,clip);
-
-    frame_clip_on();
-  }
-  else if (value > 0)
-    { 
-      double tmpw, tmph;
-      double tmpx, tmpy;
-
-      tmpw = clip_region[2];
-      tmph = clip_region[3];
-      
-      tmpx = clip_region[0];
-      tmpy = clip_region[1];
-      
-      if(ppsubwin->axes.reverse[0] == TRUE)
-       tmpx = tmpx + tmpw;
-      
-      if(ppsubwin->axes.reverse[1] == TRUE)
-       tmpy = tmpy - tmph;
-      
-      x = XDouble2Pixel( tmpx);
-      y = YDouble2Pixel( tmpy);
-      w = WDouble2Pixel( tmpx, tmpw);
-      h = HDouble2Pixel( tmpy, tmph);
-      C2F(dr)("xset","clipping",&x, &y, &w, &h,PI0,PI0,PD0,PD0,PD0,PD0,4L,8L);
-    }
-}
-
-/**sciClip
- * Clear the clipping rectangle 
- * @author Djalel ABDEMOUCHE
- * 29/11/2002
- */
-void
-sciUnClip (sciPointObj * pobj)
-{
-  int value = sciGetIsClipping(pobj);     /* clipping state */
-  
-  if (value > -1)
-    C2F(dr)("xset","clipoff",PI0,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,4L,7L);
-}
-
-
-int Gen3DPoints(integer type,integer *polyx, integer *polyy, integer *fill, integer whiteid, double zmin, double zmax, double *x, double *y, double *z, integer i, integer j, integer jj1, integer *p, integer dc, integer fg, sciPointObj * psurface)
-{
-  sciPointObj *pobj;
-  int facteur = 1;
-
-  sciPointObj *psubwin = sciGetSelectedSubWin (sciGetCurrentFigure ());
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  sciSurface * ppsurface = pSURFACE_FEATURE (psurface);
-  
-  pobj = sciGetSelectedSubWin (sciGetCurrentFigure ()); 
-  if (trans3d(pobj ,1, &(polyx[  5*jj1]),&(polyy[  5*jj1]),&(x[i]),&(y[j]),&(z[i+(*p)*j]))==0) return 0; 
-  if (trans3d(pobj ,1, &(polyx[1+  5*jj1]),&(polyy[1+  5*jj1]),&(x[i]),&(y[j+1]),&(z[i+(*p)*(j+1)]))==0) return 0; 
-  if (trans3d(pobj ,1, &(polyx[2+  5*jj1]),&(polyy[2+  5*jj1]),&(x[i+1]),&(y[j+1]),&(z[(i+1)+(*p)*(j+1)]))==0) return 0; 
-  if (trans3d(pobj ,1, &(polyx[3+  5*jj1]),&(polyy[3+  5*jj1]),&(x[i+1]),&(y[j]),&(z[(i+1)+(*p)*j]))==0) return 0;   
-  if (trans3d(pobj ,1, &(polyx[4+  5*jj1]),&(polyy[4+  5*jj1]),&(x[i]),&(y[j]),&(z[i+(*p)*j]))==0) return 0; 
-  
-  
-  if(ppsubwin->axes.reverse[0] == TRUE) facteur = -facteur;
-  if(ppsubwin->axes.reverse[1] == TRUE) facteur = -facteur;
-  if(ppsubwin->axes.reverse[2] == TRUE) facteur = -facteur;
-  
-  /* try */
-  facteur = ppsurface->flag_x * ppsurface->flag_y * facteur;
-  
-  /* type == flagcolor and dc == color_mode */
-  /* fg = hidden color */
-  
-  if ((((polyx[1+5*jj1]-polyx[0+5*jj1])*(polyy[2+5*jj1]-polyy[0+5*jj1])-
-       (polyy[1+5*jj1]-polyy[0+5*jj1])*(polyx[2+5*jj1]-polyx[0+5*jj1]))*facteur <  0) && (fg >=0 )) 
-    {
-      
-      /* ------------------- */
-      /* Beneath the surface */
-      /* ------------------- */
-
-      if (type != 0) /* flagcolor = 1 case : special treatment compared to flagcolor = 0 */
-                    /* don't know why... F.Leray */
-       fill[jj1]= (dc < 0 ) ? -fg : fg ;
-      else           /* flagcolor = 0 :  No shading at all, fixed facecolor. */
-       fill[jj1]=  (dc != 0 ) ? fg : dc ;
-    }
-  else
-    {
-
-      /* ------------------- */
-      /* Above the surface */
-      /* ------------------- */
-
-     if (type != 0)
-       {  /* flagcolor = 1 :  Z-level flat shading. */
-         fill[jj1]=inint((whiteid-1)*((1/4.0*( z[i+(*p)*j]+ z[i+1+(*p)*j]+
-                                               z[i+(*p)*(j+1)]+ z[i+1+(*p)*(j+1)])-zmin)
-                                      /(zmax-zmin)))+1;
-         if ( dc < 0 ) fill[jj1]= -fill[jj1];  
-       }
-      else
-       fill[jj1]= dc;     
-    }
-  
-  return(1);
-  
-}
-
-
-
-int Merge3dDimension(sciPointObj *pparent)
-{
-  integer N,q; 
-  sciSons *psonstmp;
-
-  /* ========================================================================
-   * Compute the number of facets, segments,... included in all the subwin 
-   * children
-   * Each entities to merge; is decomposed in a set of basic elements 
-   *  (facet, segment, point,...)
-   * Each basic element is represented in the Merge structure by the handle of its entity and an 
-   *   index within this entity
-   * ========================================================================*/
-
-  q=0;
-  psonstmp = sciGetSons (pparent);
-  while (psonstmp != (sciSons *) NULL) {   
-    switch (sciGetEntityType (psonstmp->pointobj)) {  
-    case SCI_SURFACE:
-      if (pSURFACE_FEATURE (psonstmp->pointobj)->typeof3d == SCI_PLOT3D) 
-       N=(pSURFACE_FEATURE (psonstmp->pointobj)->dimzx-1)*(pSURFACE_FEATURE (psonstmp->pointobj)->dimzy-1);
-      else
-       N = pSURFACE_FEATURE (psonstmp->pointobj)->dimzy;
-      break;
-
-    case  SCI_POLYLINE:
-      {
-        if ( pPOLYLINE_FEATURE(psonstmp->pointobj)->n1 == 0 )
-        {
-          N = 0 ;
-        }
-        else if (pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 5)
-        {/*polyline*/
-          N = pPOLYLINE_FEATURE (psonstmp->pointobj)->n1-1;
-          if ((pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 2) && 
-            (sciGetIsMark((sciPointObj *)psonstmp->pointobj) == 1))
-          {
-            N = N + 1 ;
-          }
-        }
-        else /* patch */
-        {
-          N = 1 ;
-        }
-      }
-      break;
-    case  SCI_SEGS: 
-      N=pSEGS_FEATURE (psonstmp->pointobj)->Nbr1 / 2 ;
-      break;
-    case  SCI_RECTANGLE: 
-      N = 4;
-      break;
-    case SCI_AGREG:
-      N =  Merge3dDimension(psonstmp->pointobj);
-      break;
-    default:
-      N=0;
-    }
-    q+=N;
-    psonstmp = psonstmp->pnext;
-  }
-
-  return q;
-}
-
-int ChildrenCounter(sciPointObj *pparent)
-{
-  int N,q=0;
-  sciSons * psonstmp = sciGetSons (pparent);
-  
-  while (psonstmp != (sciSons *) NULL) {   
-    switch (sciGetEntityType (psonstmp->pointobj)) {  
-    case SCI_SURFACE:
-      N=1;
-      break;
-    case  SCI_POLYLINE:
-      N = 1; 
-      break;
-    case  SCI_SEGS: 
-      N=1;
-      break;
-    case  SCI_RECTANGLE: 
-      N = 1;
-      break;
-    case SCI_AGREG:
-      N = ChildrenCounter(psonstmp->pointobj);
-      break;
-    default:
-      N=0;
-    }
-    q+=N;
-    psonstmp = psonstmp->pnext;
-  }
-
-  return q;
-}
-
-
-void Merge3dBuildTable(sciPointObj *pparent, int *index_in_entity, long *from_entity, int *pos)
-{
-  sciSons *psonstmp;
-  int i,N;
-
-  psonstmp = sciGetSons (pparent);
-
-  while (psonstmp != (sciSons *) NULL) {   
-    switch (sciGetEntityType (psonstmp->pointobj)) {  
-    case SCI_SURFACE:
-      if (pSURFACE_FEATURE (psonstmp->pointobj)->typeof3d == SCI_PLOT3D) 
-       N=(pSURFACE_FEATURE (psonstmp->pointobj)->dimzx-1)*(pSURFACE_FEATURE (psonstmp->pointobj)->dimzy-1);
-      else
-       N = pSURFACE_FEATURE (psonstmp->pointobj)->dimzy;
-      break;
-    case  SCI_POLYLINE:
-      if ( pPOLYLINE_FEATURE(psonstmp->pointobj)->n1 == 0 )
-      {
-        N = 0 ;
-      }
-      else if (pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 5)
-      {/*polyline*/
-       N = pPOLYLINE_FEATURE (psonstmp->pointobj)->n1-1;
-       if ((pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 2) && 
-           (sciGetIsMark((sciPointObj *)psonstmp->pointobj) == 1))
-        {
-         N = N + 1 ;
-        }
-      }
-      else /* patch */
-      {
-       N = 1 ;
-      }
-      break;
-    case  SCI_SEGS: 
-      N=pSEGS_FEATURE (psonstmp->pointobj)->Nbr1/2;
-      break;
-    case  SCI_RECTANGLE: 
-      N = 4;
-      break;
-    case SCI_AGREG:
-      Merge3dBuildTable(psonstmp->pointobj, index_in_entity, from_entity, pos);
-      break;
-    default:
-      N = 0;
-    }
-    if (sciGetEntityType (psonstmp->pointobj) != SCI_AGREG)
-      for (i=0 ; i<N; i++) {
-       index_in_entity[*pos]=i;
-       from_entity[*pos]=(long) sciGetHandle (psonstmp->pointobj);
-       *pos=*pos+1;
-      }
-    psonstmp = psonstmp->pnext;
-  }
-}
-
-
-void Merge3d(sciPointObj *psubwin)
-{
-  integer q,k; 
-  sciPointObj *pmerge; 
-  int *index_in_entity;
-  long *from_entity;
-  
-  if(sciGetEntityType (psubwin) != SCI_SUBWIN) return; 
-  if ((pmerge= sciGetMerge(psubwin)) != (sciPointObj *) NULL)
-    DestroyMerge(pmerge); 
-  
-  /* ========================================================================
-   * Compute the number of facets, segments,... included in all the subwin 
-   * children
-   * ========================================================================*/
-  
-  
-  q =  Merge3dDimension(psubwin);
-  
-  
-  /* ========================================================================
-   * allocate tables for index and handles
-   * ========================================================================*/
-  
-  /* q now contains the total number of elements */
-  if ((index_in_entity = (int *) MALLOC (q * sizeof (int))) == (int *)NULL) {
-    Scistring("Merge3d : not enough memory to allocate \n");
-    return;
-  }
-  if ((from_entity   = (long *) MALLOC (q * sizeof (long))) == (long *) NULL) {
-    Scistring("Merge3d : not enough memory to allocate \n");
-    FREE(index_in_entity);
-  }
-  
-  /* ========================================================================
-   * fill the index and handles tables
-   * ========================================================================*/
-  k=0;
-  Merge3dBuildTable(psubwin, index_in_entity, from_entity, &k);
-  
-  /* ========================================================================
-   * create the Merge data structure
-   * ========================================================================*/
-  
-  if ((pmerge=ConstructMerge ((sciPointObj *) psubwin,q,index_in_entity,from_entity)) == (sciPointObj *) NULL) {
-    FREE(index_in_entity);
-    FREE(from_entity);
-    sciprint ("\r\n No merge supported");}
-  else /* inform the subwindow to display Merge instead of individual children */
-    pSUBWIN_FEATURE (psubwin)->facetmerge = TRUE;
-  
-}
-
-/*------------------------------------------------------------------------------------------*/
-/**
-* get the coordiantes of the vertices of a facet in a FAC3D object
-* @param[in/out] pobj       surface object of type Fac3d
-* @param         facetIndex index of the facet in the object
-* @param[out]    verticesX  list of X coordinates of the vertices
-* @param[out]    verticesY  list of Y coordinates of the vertices
-* @param[out]    verticesZ  list of Z coordinates of the vertices
-* @param[out]    zOriginal  pointer on the Z coordinate of the first vertex in the fac3d object
-*/
-void retrieveFacetVertices( sciPointObj *  pobj       ,
-                           int            facetIndex ,
-                           double         verticesX[],
-                           double         verticesY[],
-                           double         verticesZ[],
-                           double      ** zOriginal   )
-{
-  int nbFacets = pSURFACE_FEATURE (pobj)->dimzx ;
-  int i ;
-
-  for ( i = 0 ; i < nbFacets ; i++ )
-  {
-    verticesX[i] = pSURFACE_FEATURE(pobj)->pvecx[facetIndex * nbFacets + i] ;
-    verticesY[i] = pSURFACE_FEATURE(pobj)->pvecy[facetIndex * nbFacets + i] ;
-    verticesZ[i] = pSURFACE_FEATURE(pobj)->pvecz[facetIndex * nbFacets + i] ;
-  }
-
-  ReverseDataFor3D( pobj, verticesX, verticesY, verticesZ, nbFacets ) ;
-
-  *zOriginal = &(pSURFACE_FEATURE(pobj)->pvecz[facetIndex * nbFacets]) ;
-}
-/*------------------------------------------------------------------------------------------*/
-
-void DrawMerge3d(sciPointObj *psubwin, sciPointObj *pmerge, int * DPI)
-{
-  int N,i,j,index_,p,max_p,n1,npoly;
-  double * dist;
-  double X[5],Y[5],Z[5];
-  double * Zoriginal = NULL; /* used to conserve Z wether or not z axis is reversed ! (see plo3dn.c) */
-  double * x = NULL ;
-  double * y = NULL ;
-  double * z = NULL ;
-  sciPointObj *pobj; 
-  int *locindex;
-  int *polyx,*polyy,fill[20];/* here we suppose there is no more than 20 edge in a facet */
-  int k1,iflag;
-  int pstyle = 0;
-  int whiteid,verbose=0,narg;
-  static double zmin,zmax,xmoy,ymoy,zmoy,zl;
-  int context[6];
-  
-
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (psubwin);
-  sciMerge     * ppMerge  = pMERGE_FEATURE (pmerge) ;
-  int u;
-  /* change to static arrays : indeed, no need to recopy each time the entire data of a given object */
-  double   xtmp[2] ; 
-  double   ytmp[2] ;
-  double   ztmp[4] ;
-
-  double * verticesX = NULL ; /* normally max size is 4 for facets (2 for lines and segs) but may be one day we will manage greater complex patchs (that is why the 10) */
-  double * verticesY = NULL ;  /* no it can have any size, but display of facets with more than 4 edges might not be accurate */
-  double * verticesZ = NULL ;
-  
-#ifdef _MSC_VER 
-  int hdcflag;
-#endif
-
-  if(sciGetEntityType (psubwin) != SCI_SUBWIN) return;
-  N = ppMerge->N ; /* total number of elements */
-  
-  if ((dist=(double *)MALLOC(N*sizeof(double)))==(double *) NULL) {
-    Scistring("DrawMerge3d : MALLOC No more Place\n");
-    return;
-  }
-  if ((locindex=(int *)MALLOC(N*sizeof(int)))==(int *) NULL) {
-    Scistring("DrawMerge3d : MALLOC No more Place\n");
-    return;
-  }
-
-  /* ========================================================================
-   * compute drawing order (painter algorithm) *
-   may be moved into Merge3d
-   * ========================================================================*/
-  max_p=0; /* the maximum number of edge in a facet */
-  for ( i =0 ; i < N ; i++) { /* loop on element*/
-    pobj=(sciPointObj *) sciGetPointerFromHandle (ppMerge->from_entity[i]);
-    index_ = ppMerge->index_in_entity[i];
-
-    /*compute element coordinates */
-    switch (sciGetEntityType (pobj)) {  
-    case SCI_SURFACE:
-      if (pSURFACE_FEATURE (pobj)->typeof3d == SCI_PLOT3D) { /* x,y,Z */
-       int l,k,n1_,n2;
-
-       n1_= pSURFACE_FEATURE (pobj)->dimzx;
-       n2= pSURFACE_FEATURE (pobj)->dimzy;
-       l=(int)(index_/(n1_-1));
-       k=index_-l*(n1_-1);
-
-       xtmp[0] = pSURFACE_FEATURE (pobj)->pvecx[k];
-       xtmp[1] = pSURFACE_FEATURE (pobj)->pvecx[k+1];
-       
-       /* I didn't use ReverseDataFor3D because dim n1 is not the same for x, y and z  */
-       if(ppsubwin->axes.reverse[0] == TRUE){
-         /* agir sur x */
-         if(ppsubwin->logflags[0]=='l'){
-           for(u=0;u<2;u++){
-             xtmp[u] = log10(xtmp[u]);
-             xtmp[u] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp[u]);
-             xtmp[u] = exp10(xtmp[u]);
-           }
-         }
-         else {
-           xtmp[0] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp[0]);
-           xtmp[1] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp[1]);
-         }
-       }
-
-       ytmp[0] = pSURFACE_FEATURE (pobj)->pvecy[l];
-       ytmp[1] = pSURFACE_FEATURE (pobj)->pvecy[l+1];
-
-       if(ppsubwin->axes.reverse[1] == TRUE){ 
-         /* agir sur y */
-         if(ppsubwin->logflags[1]=='l'){
-           for(u=0;u<2;u++){
-             ytmp[u] = log10(ytmp[u]);
-             ytmp[u] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp[u]);
-             ytmp[u] = exp10(ytmp[u]);
-           }
-         }
-         else{
-           ytmp[0] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp[0]);
-           ytmp[1] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp[1]);
-         }
-       }
-
-       ztmp[0] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_];
-       ztmp[1] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_+n1_];
-       ztmp[2] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_+n1_+1];
-       ztmp[3] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_+1];
-
-
-       if(ppsubwin->axes.reverse[2] == TRUE){ 
-         /* agir sur z */
-         if(ppsubwin->logflags[2]=='l'){
-           for(u=0;u<4;u++){
-             ztmp[u] = log10(ztmp[u]);
-             ztmp[u] = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp[u]);
-             ztmp[u] = exp10(ztmp[u]);
-           }
-         }
-         else{
-           for(u=0;u<4;u++)
-             ztmp[u] = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp[u]);
-         }
-       }
-  
-       n2= pSURFACE_FEATURE (pobj)->dimzy;
-       X[0]=X[1]=xtmp[0];
-       X[2]=X[3]=xtmp[1];
-
-       Z[0]=ztmp[0];
-       Z[1]=ztmp[1];
-       Z[2]=ztmp[2];
-       Z[3]=ztmp[3];
-
-       Y[0]=Y[3]=ytmp[0];
-       Y[1]=Y[2]=ytmp[1];
-
-       Zoriginal = &(pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_]);
-       
-       p=4;
-       x=X;y=Y;z=Z;
-       
-      }
-      else
-      {
-        /* facets */
-        p = pSURFACE_FEATURE (pobj)->dimzx; /* number of edges in the facets */
-
-        verticesX = MALLOC( p * sizeof(double) ) ;
-        verticesY = MALLOC( p * sizeof(double) ) ;
-        verticesZ = MALLOC( p * sizeof(double) ) ;
-
-        if ( verticesX == NULL || verticesY == NULL || verticesZ == NULL )
-        {
-          FREE(verticesX) ;
-          FREE(verticesY) ;
-          FREE(verticesZ) ;
-          sciprint( "sciDrawObj: Unable to allocate temporary vector, memory full.\n" ) ;
-          return ;
-        }
-
-        retrieveFacetVertices( pobj, index_, verticesX, verticesY, verticesZ, &Zoriginal ) ;
-
-        x = verticesX ;
-        y = verticesY ;
-        z = verticesZ ;
-
-      }
-      break;
-    case  SCI_POLYLINE:
-    {
-      sciPolyline * ppPolyLine = pPOLYLINE_FEATURE (pobj) ;
-      n1 = ppPolyLine->n1 ;
-      p  = 0 ;
-      if ( sciGetIsMark(pobj) ) { p = 1 ; } /* F.Leray 20.01.05 A REVOIR ICI*/
-      if ( sciGetIsLine(pobj) ) { p = 2 ; }
-      
-      if ( ppPolyLine->plot != 2 && sciGetIsMark(pobj) == 1 )
-      {
-        xtmp[0] = ppPolyLine->pvx[index_];
-        xtmp[1] = xtmp[0] ;
-        
-        ytmp[0] = ppPolyLine->pvy[index_];
-        ytmp[1] = ytmp[0] ; /* used by trans3d + drawing : case 0,1 and 4 */
-
-        if( ppPolyLine->pvz != NULL )
-        {
-          ztmp[0] = ppPolyLine->pvz[index_];
-          ztmp[1] = ztmp[0];
-        }
-      }
-      else
-      {
-        xtmp[0] = ppPolyLine->pvx[index_];
-        xtmp[1] = ppPolyLine->pvx[index_+1];
-        
-        ytmp[0] = ppPolyLine->pvy[index_];
-        ytmp[1] = ppPolyLine->pvy[index_+1]; /* used by trans3d + drawing : case 0,1 and 4 */
-        if( ppPolyLine->pvz != NULL )
-        {
-          ztmp[0] = ppPolyLine->pvz[index_];
-          ztmp[1] = ppPolyLine->pvz[(index_+1)%n1];
-        }
-      }
-      
-      if( ppPolyLine->pvz != NULL )
-      {
-       ReverseDataFor3D(psubwin,xtmp,ytmp,ztmp,2);
-      }
-      else
-      {
-       ReverseDataFor3D(psubwin,xtmp,ytmp,(double *) NULL,2);
-      }
-      
-      switch ( ppPolyLine->plot )
-      {
-      case 0: case 1: case 4: /*linear interpolation */
-       x=&(xtmp[0]);
-       y=&(ytmp[0]);
-       if ( ppPolyLine->pvz != (double *) NULL) 
-         z=&(ztmp[0]);
-       else
-         z=(double *)NULL;
-       break;
-      case 2: /* staircase */ /* just for completion  */
-       X[0]=xtmp[0];
-       X[1]=xtmp[1];
-       Y[0]=ytmp[0];
-       Y[1]=ytmp[0];
-       if (ppPolyLine->pvz != (double *) NULL) {
-         Z[0]=ztmp[0];
-         Z[1]=ztmp[0];
-         z=Z;
-       }
-       else 
-         z=(double *)NULL;
-       x=X;y=Y;
-       break;
-      case 3 : /* vertical bar */ /* just for completion  */
-       X[0]=xtmp[0];
-       X[1]=xtmp[0];
-       Y[0]=0.0;
-       if(ppsubwin->logflags[1]=='l') /* when logscale on Y, special treatment because we can not have Y == 0 */
-         Y[0] = ppsubwin->FRect[1];
-       Y[1]=ytmp[0];
-       if ( ppPolyLine->pvz != (double *) NULL) {
-         Z[0]=ztmp[0];
-         Z[1]=ztmp[0];
-         z=Z;
-       }
-       else 
-         z=(double *)NULL;
-       x=X;y=Y;
-       break;
-      case 5: /* patch */
-       x=xtmp;
-       y=ytmp;
-       if ( ppPolyLine->pvz != (double *) NULL)
-         z=ztmp;
-       else
-         z= (double *) NULL;
-       break;
-      }
-    }
-    break;
-    case  SCI_SEGS: 
-      p = 2;
-      /***************/
-
-      xtmp[0] =  pSEGS_FEATURE (pobj)->vx[2*index_];
-      xtmp[1] =  pSEGS_FEATURE (pobj)->vx[2*index_+1];
-
-      ytmp[0] =  pSEGS_FEATURE (pobj)->vy[2*index_];
-      ytmp[1] =  pSEGS_FEATURE (pobj)->vy[2*index_+1];
-      
-      
-      if(pSEGS_FEATURE (pobj)->vz != NULL){
-       ztmp[0] = pSEGS_FEATURE (pobj)->vz[2*index_];
-       ztmp[1] = pSEGS_FEATURE (pobj)->vz[2*index_+1];
-      }
-      
-      if(pSEGS_FEATURE (pobj)->vz != NULL)
-       ReverseDataFor3D(psubwin,xtmp,ytmp,ztmp,2);
-      else
-       ReverseDataFor3D(psubwin,xtmp,ytmp,(double *) NULL,2);
-       
-      /**************/
-
-      X[0]=xtmp[0];
-      X[1]=xtmp[1];
-      Y[0]=ytmp[0];
-      Y[1]=ytmp[1];
-      if (pSEGS_FEATURE (pobj)->vz != (double *) NULL) {
-       Z[0]=ztmp[0];
-       Z[1]=ztmp[1];
-       z=Z;
-      }
-      else
-       z=(double *)NULL;
-      x=X;y=Y;
-      
-      break;
-    case  SCI_RECTANGLE: 
-      {
-       double rectx[4],recty[4],rectz[4];
-       p = 5;
-       
-       rectx[0]= rectx[3] =pRECTANGLE_FEATURE (pobj)->x;
-       rectx[1]= rectx[2] =pRECTANGLE_FEATURE (pobj)->x+pRECTANGLE_FEATURE (pobj)->width;   
-       recty[0]= recty[1] =pRECTANGLE_FEATURE (pobj)->y;   
-       recty[2]= recty[3] =pRECTANGLE_FEATURE (pobj)->y-pRECTANGLE_FEATURE (pobj)->height;
-       rectz[0]= rectz[1]=rectz[2]= rectz[3]=pRECTANGLE_FEATURE (pobj)->z;
-       
-       ReverseDataFor3D(psubwin, rectx, recty, rectz, 4);
-      
-       X[0]=X[1]=X[4]=rectx[0];
-       Y[0]=Y[3]=Y[4]=recty[0];
-       X[2]=X[3]=rectx[1];
-       Y[1]=Y[2]=recty[2];
-       Z[0]=Z[1]=Z[2]=Z[3]=Z[4]=rectz[0];
-       x=X;y=Y;z=Z; 
-      }
-      break;
-    default:
-      p = 0;
-    }
-    /* each element is represented by its barycenter */
-    xmoy=0.0;ymoy=0.0;zmoy=0.0;
-    if (z != (double *)NULL) {
-      for ( j= 0 ; j < p ; j++) {
-       xmoy += x[j];  ymoy += y[j];  zmoy += z[j];
-      }
-    }
-    else {
-      for ( j= 0 ; j < p ; j++) {
-       xmoy += x[j];  ymoy += y[j];
-      }
-    }
-    /* Compute the distance from the observer */
-    dist[i]=  TRZ(xmoy/p,ymoy/p,zmoy/p);
-    max_p=Max(max_p,p);
-
-  } /* END of FOR here F.Leray 01.12.04 */
-
-  /* sort the distance in decreasing order */
-  C2F(dsort)(dist,&N,locindex); 
-
-  FREE(verticesX) ;
-  FREE(verticesY) ;
-  FREE(verticesZ) ;
-
-  /* ========================================================================
-   * draw each element in the order given by locindex
-   * ========================================================================*/
-  C2F(dr)("xget","lastpattern",&verbose,&whiteid,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-
-  zmin = pSUBWIN_FEATURE (psubwin)->SRect[4];
-  zmax = pSUBWIN_FEATURE (psubwin)->SRect[5];
-  if ((polyx=(int *)MALLOC((max_p+1)*sizeof(int)))==(int *) NULL) {
-    FREE(dist);FREE(locindex);
-    Scistring("DrawMerge3d : MALLOC No more Place\n");
-
-    return;
-  }
-  if ((polyy=(int *)MALLOC((max_p+1)*sizeof(int)))==(int *) NULL) {
-    FREE(dist);FREE(locindex);
-    Scistring("DrawMerge3d : MALLOC No more Place\n");
-    return;
-  }
-  npoly=1; 
-  for ( i = N ; i>0 ; i--) { /* loop on elements */
-    int j2,nok;
-    j2=locindex[i-1]-1;
-    index_= ppMerge->index_in_entity[j2];
-    pobj=(sciPointObj *) sciGetPointerFromHandle (ppMerge->from_entity[j2]);
-    /*     if (sciGetVisibility (pobj)) { */
-    if ( sciGetRealVisibility(pobj) ) {
-      /* build the element coordinates */
-      switch (sciGetEntityType (pobj)) {  
-      case SCI_SURFACE:
-       if (pSURFACE_FEATURE (pobj)->typeof3d == SCI_PLOT3D) { /* x,y,Z */
-         int l,k,n1_,n2;
-
-         n1_= pSURFACE_FEATURE (pobj)->dimzx;
-         n2= pSURFACE_FEATURE (pobj)->dimzy;
-         l=(int)(index_/(n1_-1));
-         k=index_-l*(n1_-1);
-
-         xtmp[0] = pSURFACE_FEATURE (pobj)->pvecx[k];
-         xtmp[1] = pSURFACE_FEATURE (pobj)->pvecx[k+1];
-         
-         /* I didn't use ReverseDataFor3D because dim n1 is not the same for x, y and z  */
-         if(ppsubwin->axes.reverse[0] == TRUE){
-           /* agir sur x */
-           if(ppsubwin->logflags[0]=='l'){
-             for(u=0;u<2;u++){
-               xtmp[u] = log10(xtmp[u]);
-               xtmp[u] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp[u]);
-               xtmp[u] = exp10(xtmp[u]);
-             }
-           }
-           else {
-             xtmp[0] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp[0]);
-             xtmp[1] = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp[1]);
-           }
-         }
-
-         ytmp[0] = pSURFACE_FEATURE (pobj)->pvecy[l];
-         ytmp[1] = pSURFACE_FEATURE (pobj)->pvecy[l+1];
-
-         if(ppsubwin->axes.reverse[1] == TRUE){ 
-           /* agir sur y */
-           if(ppsubwin->logflags[1]=='l'){
-             for(u=0;u<2;u++){
-               ytmp[u] = log10(ytmp[u]);
-               ytmp[u] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp[u]);
-               ytmp[u] = exp10(ytmp[u]);
-             }
-           }
-           else{
-             ytmp[0] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp[0]);
-             ytmp[1] = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp[1]);
-           }
-         }
-
-         ztmp[0] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_];
-         ztmp[1] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_+n1_];
-         ztmp[2] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_+n1_+1];
-         ztmp[3] = pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_+1];
-
-
-         if(ppsubwin->axes.reverse[2] == TRUE){ 
-           /* agir sur z */
-           if(ppsubwin->logflags[2]=='l'){
-             for(u=0;u<4;u++){
-               ztmp[u] = log10(ztmp[u]);
-               ztmp[u] = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp[u]);
-               ztmp[u] = exp10(ztmp[u]);
-             }
-           }
-           else{
-             for(u=0;u<4;u++)
-               ztmp[u] = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp[u]);
-           }
-         }
-         
-         n2= pSURFACE_FEATURE (pobj)->dimzy;
-         X[0]=X[1]=xtmp[0];
-         X[2]=X[3]=xtmp[1];
-         Z[0]=ztmp[0];
-         Z[1]=ztmp[1];
-         Z[2]=ztmp[2];
-         Z[3]=ztmp[3];
-         
-         Y[0]=Y[3]=ytmp[0];
-         Y[1]=Y[2]=ytmp[1];
-         
-         Zoriginal = &(pSURFACE_FEATURE (pobj)->pvecz[k+l*n1_]);
-         
-         p=4;
-         x=X;y=Y;z=Z;
-         
-       }
-       else
-        {
-          /* facets */
-          p = pSURFACE_FEATURE (pobj)->dimzx; /* number of edges in the facets */
-
-          verticesX = MALLOC( p * sizeof(double) ) ;
-          verticesY = MALLOC( p * sizeof(double) ) ;
-          verticesZ = MALLOC( p * sizeof(double) ) ;
-
-          if ( verticesX == NULL || verticesY == NULL || verticesZ == NULL )
-          {
-            FREE(verticesX) ;
-            FREE(verticesY) ;
-            FREE(verticesZ) ;
-            sciprint( "sciDrawObj: Unable to allocate temporary vector, memory full.\n" ) ;
-            return ;
-          }
-
-          retrieveFacetVertices( pobj, index_, verticesX, verticesY, verticesZ, &Zoriginal ) ;
-
-          x = verticesX ;
-          y = verticesY ;
-          z = verticesZ ;
-       }
-       break;
-      case  SCI_POLYLINE:
-        {
-          sciPolyline * ppPolyLine = pPOLYLINE_FEATURE( pobj ) ;
-          n1 = ppPolyLine->n1 ;
-          p=0;
-          if ( sciGetIsMark( pobj ) ) { p=1 ; } /* F.Leray 20.01.05 A REVOIR ICI*/
-          if ( sciGetIsLine( pobj ) ) { p=2 ; }
-          
-          /* check if we want to draw segments or marks */
-          if ( ppPolyLine->plot != 2 && sciGetIsMark(pobj) == 1 )
-          {
-            xtmp[0] = ppPolyLine->pvx[index_];
-            xtmp[1] = xtmp[0] ;
-            
-            ytmp[0] = ppPolyLine->pvy[index_];
-            ytmp[1] = ytmp[0] ; /* used by trans3d + drawing : case 0,1 and 4 */
-            if(ppPolyLine->pvz != NULL)
-            {
-              ztmp[0] = ppPolyLine->pvz[index_];
-              ztmp[1] = ztmp[0] ;
-            }
-          }
-          else
-          {
-            xtmp[0] = ppPolyLine->pvx[index_];
-            xtmp[1] = ppPolyLine->pvx[index_+1];
-            
-            ytmp[0] = ppPolyLine->pvy[index_];
-            ytmp[1] = ppPolyLine->pvy[index_+1]; /* used by trans3d + drawing : case 0,1 and 4 */
-            
-            if(ppPolyLine->pvz != NULL)
-            {
-              ztmp[0] = ppPolyLine->pvz[index_];
-              ztmp[1] = ppPolyLine->pvz[(index_+1)%n1];
-            }
-          }
-          
-          if(ppPolyLine->pvz != NULL)
-            ReverseDataFor3D(psubwin,xtmp,ytmp,ztmp,2);
-          else
-            ReverseDataFor3D(psubwin,xtmp,ytmp,(double *) NULL,2);
-          
-          switch (ppPolyLine->plot) {
-          case 0: case 1: case 4: /*linear interpolation */
-            x=&(xtmp[0]);
-            y=&(ytmp[0]);
-            if (ppPolyLine->pvz != (double *) NULL) 
-              z=&(ztmp[0]);
-            else
-              z=(double *)NULL;
-            break;
-          case 2: /* staircase */ /* just for completion  */
-            X[0]=xtmp[0];
-            X[1]=xtmp[1];
-            Y[0]=ytmp[0];
-            Y[1]=ytmp[0];
-            if (ppPolyLine->pvz != (double *) NULL) {
-              Z[0]=ztmp[0];
-              Z[1]=ztmp[0];
-              z=Z;
-            }
-            else 
-              z=(double *)NULL;
-            x=X;y=Y;
-            break;
-          case 3 : /* vertical bar */ /* just for completion  */
-            X[0]=xtmp[0];
-            X[1]=xtmp[0];
-            Y[0]=0.0;
-            if(ppsubwin->logflags[1]=='l') /* when logscale on Y, special treatment because we can not have Y == 0 */
-              Y[0] = ppsubwin->FRect[1];
-            Y[1]=ytmp[0];
-            if (ppPolyLine->pvz != (double *) NULL) {
-              Z[0]=ztmp[0];
-              Z[1]=ztmp[0];
-              z=Z;
-            }
-            else 
-              z=(double *)NULL;
-            x=X;y=Y;
-            break;
-          case 5: /* patch*/
-            x=xtmp;
-            y=ytmp;
-            if (ppPolyLine->pvz != (double *) NULL)
-              z=ztmp;
-            else
-              z= (double *) NULL;
-            break;
-          }
-        }
-       break;
-      case  SCI_SEGS: 
-       p = 2;
-       /***************/
-       
-       if (pSEGS_FEATURE (pobj)->ptype == 0) /* ptype == 0 F.Leray : This is NOT A champ */
-         {  
-           if (pSEGS_FEATURE (pobj)->iflag == 1) {
-             pstyle=sciGetGoodIndex(pobj, pSEGS_FEATURE (pobj)->pstyle[index_]);
-           }
-           else{
-             pstyle=sciGetGoodIndex(pobj, pSEGS_FEATURE (pobj)->pstyle[0]);
-           }
-         }
-       else
-         {
-           pstyle=sciGetGoodIndex(pobj, pSEGS_FEATURE (pobj)->pstyle[0]);
-         }
-       
-       iflag = pSEGS_FEATURE (pobj)->iflag;
-       
-       xtmp[0] =  pSEGS_FEATURE (pobj)->vx[2*index_];
-       xtmp[1] =  pSEGS_FEATURE (pobj)->vx[2*index_+1];
-       
-       ytmp[0] =  pSEGS_FEATURE (pobj)->vy[2*index_];
-       ytmp[1] =  pSEGS_FEATURE (pobj)->vy[2*index_+1];
-       
-       
-       if(pSEGS_FEATURE (pobj)->vz != NULL){
-         ztmp[0] = pSEGS_FEATURE (pobj)->vz[2*index_];
-       ztmp[1] = pSEGS_FEATURE (pobj)->vz[2*index_+1];
-       }
-       
-      
-       if(pSEGS_FEATURE (pobj)->vz != NULL)
-         ReverseDataFor3D(psubwin,xtmp,ytmp,ztmp,2);
-       else
-         ReverseDataFor3D(psubwin,xtmp,ytmp,(double *) NULL,2);
-       
-       /**************/
-
-       X[0]=xtmp[0];
-       X[1]=xtmp[1];
-       Y[0]=ytmp[0];
-       Y[1]=ytmp[1];
-       if (pSEGS_FEATURE (pobj)->vz != (double *) NULL) {
-         Z[0]=ztmp[0];
-         Z[1]=ztmp[1];
-         z=Z;
-       }
-       else
-         z=(double *)NULL;
-       x=X;y=Y;
-       
-       break;
-      case  SCI_RECTANGLE: 
-       {
-         double rectx[4],recty[4],rectz[4];
-         p = 5;
-       
-         pstyle=0; /* arevoir */
-         iflag=0; /* arevoir */
-      
-         rectx[0]= rectx[3] =pRECTANGLE_FEATURE (pobj)->x;
-         rectx[1]= rectx[2] =pRECTANGLE_FEATURE (pobj)->x+pRECTANGLE_FEATURE (pobj)->width;   
-         recty[0]= recty[1] =pRECTANGLE_FEATURE (pobj)->y;   
-         recty[2]= recty[3] =pRECTANGLE_FEATURE (pobj)->y-pRECTANGLE_FEATURE (pobj)->height;
-         rectz[0]= rectz[1]=rectz[2]= rectz[3]=pRECTANGLE_FEATURE (pobj)->z;
-      
-         ReverseDataFor3D(psubwin, rectx, recty, rectz, 4);
-      
-         X[0]=X[1]=X[4]=rectx[0];
-         Y[0]=Y[3]=Y[4]=recty[0];
-         X[2]=X[3]=rectx[1];
-         Y[1]=Y[2]=recty[2];
-         Z[0]=Z[1]=Z[2]=Z[3]=Z[4]=rectz[0];
-         x=X;y=Y;z=Z; 
-       }
-       break;
-      default:
-       p = 0;
-      }
-      
-      nok = 0;
-
-      if (p > 0) {
-       /* project 3D on 2D coordinates */
-       if (z != (double *)NULL) {
-         for ( j2 =0 ; j2 < p ; j2++) { 
-           if (trans3d(psubwin ,1, &(polyx[j2]),&(polyy[j2]),&(x[j2]),&(y[j2]),&(z[j2]))==0) {
-             nok=1;break; 
-           }
-         }
-       }
-       else {
-         double zz=0.0;
-         for ( j2 =0 ; j2 < p ; j2++) { 
-           if (trans3d(psubwin ,1, &(polyx[j2]),&(polyy[j2]),&(x[j2]),&(y[j2]),&zz)==0) {
-             nok=1;break; 
-           }
-         }
-       }
-
-       if(nok == 1) continue;
-
-       /* draw element */
-       context[0] = sciGetForeground (pobj);   
-       context[1] = sciGetLineWidth (pobj);
-       context[2] = sciGetLineStyle (pobj); 
-       context[3] = 0;
-       context[4] = sciGetMarkStyle(pobj);
-       context[5] = sciGetLineWidth (pobj);
-#ifdef _MSC_VER
-       hdcflag=MaybeSetWinhdc();
-#endif
-       C2F (dr) ("xset", "thickness",  context+1, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 5L, 9L);
-       C2F (dr) ("xset", "line style", context+2, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L); 
-       C2F (dr) ("xset", "mark", context+4, context+5, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 4L, 4L);
-
-       if (sciGetEntityType (pobj)==SCI_SURFACE) {
-         int fg1  = pSURFACE_FEATURE (pobj)->hiddencolor;
-         int flag = pSURFACE_FEATURE (pobj)->flag[0];
-         int facteur = 1;
-         
-         polyx[p] = polyx[0] ;
-          polyy[p] = polyy[0] ;
-          p++ ; /*close the facet*/
-          /* beware we got twice the first point now */
-
-         /* facteur is used below */
-         if(ppsubwin->axes.reverse[0] == TRUE) facteur = -facteur;
-         if(ppsubwin->axes.reverse[1] == TRUE) facteur = -facteur;
-         if(ppsubwin->axes.reverse[2] == TRUE) facteur = -facteur;
-         
-         if ((((polyx[1]-polyx[0])*(polyy[2]-polyy[0])-(polyy[1]-polyy[0])*(polyx[2]-polyx[0]))*facteur <  0) &&
-             (fg1 >= 0)) { /* hidden face */
-
-           if ( pSURFACE_FEATURE (pobj)->flagcolor != 0)
-             fill[0] = (flag < 0 ) ? -fg1 : fg1 ;
-           else
-             fill[0] = (flag != 0 ) ? fg1 : flag ;
-           if(sciGetIsLine(pobj)){
-             C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 6L);
-             C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 10L);
-             C2F(dr)("xliness","str",polyx,polyy,fill,&npoly,&p,PI0,PD0,PD0,PD0,PD0,0L,0L);
-           }
-           if(sciGetIsMark(pobj))
-             DrawMarks3D(pobj,5*npoly,polyx,polyy,DPI);
-         }
-         else {
-           switch ( pSURFACE_FEATURE (pobj)->flagcolor) {
-           case 0:
-             fill[0]= flag ;
-             if(sciGetIsLine(pobj)){
-               C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 6L);
-               C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 10L);
-               C2F(dr)("xliness","str",polyx,polyy,fill,&npoly,&p, PI0,PD0,PD0,PD0,PD0,0L,0L);
-             }
-             if(sciGetIsMark(pobj))
-               DrawMarks3D(pobj,5*npoly,polyx,polyy,DPI);
-             break;
-           case 1:
-             zl = 0.0 ;
-              for ( k1= 0 ; k1 < p - 1 ; k1++) { zl += z[k1] ; }
-              zl /= p - 1.0 ;
-             /* for ( k1= 0 ; k1 < p ; k1++) zl+= Zoriginal[k1]; */ /* F.Leray 01.12.04 : DO NOT REPLACE z by ztmp here : zmin & zmax are computed to work with z ! */
-             fill[0] = inint( (whiteid-1)* ( zl - zmin ) / ( zmax- zmin ) ) + 1 ;
-
-              if ( flag  < 0 ) { fill[0] = -fill[0] ; }
-             if ( sciGetIsLine(pobj) )
-              {
-               C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 6L);
-               C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 10L);
-               C2F(dr)("xliness","str",polyx,polyy,fill,&npoly,&p ,PI0,PD0,PD0,PD0,PD0,0L,0L);
-             }
-               if(sciGetIsMark(pobj))
-               DrawMarks3D(pobj,5*npoly,polyx,polyy,DPI);
-             break;
-           case 2:
-             fill[0]= (int) pSURFACE_FEATURE (pobj)->color[index_];
-             if ( flag < 0 ) fill[0]=-fill[0];
-             if(sciGetIsLine(pobj)){
-               C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 6L);
-               C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 10L);
-               C2F(dr)("xliness","str",polyx,polyy,fill,&npoly,&p ,PI0,PD0,PD0,PD0,PD0,0L,0L);
-             }
-             if(sciGetIsMark(pobj))
-               DrawMarks3D(pobj,5*npoly,polyx,polyy,DPI);
-             break;
-           case 3:
-             p--;
-             if ( (p) != 3 && (p) !=4 ) {
-               Scistring("Interpolated shading is only allowed for polygons with 3 or 4 vertices\n");
-               return;
-             }
-             else  {
-               /* shade needs (int*) color */
-               integer *cvect = NULL,ik;
-               sciSurface * ppsurface = pSURFACE_FEATURE (pobj);
-               
-               if((cvect=MALLOC(ppsurface->nc*sizeof(integer)))==NULL){
-                 sciprint("Allocation failed in merge for color matrix\n");
-                 return;
-               }    
-               
-               for(ik=0;ik<ppsurface->nc;ik++) 
-                 cvect[ik] = (int) ppsurface->color[ik];
-
-               C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 6L);
-               C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 10L);
-                       
-               scilab_shade(polyx,polyy,&(cvect[p*index_]),p,ppsurface->flag[0]);
-               FREE(cvect); cvect = NULL;
-               if (sciGetIsMark (pobj))
-                 DrawMarks3D (pobj, p,polyx,polyy,DPI);
-             }
-             break;
-           case 4: /* new case for "flat" mode matlab compatibility */
-             fill[0]= (int) pSURFACE_FEATURE (pobj)->color[index_];
-             if ( flag < 0 ) fill[0]=-fill[0];
-             if(sciGetIsLine(pobj)){
-               C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 6L);
-               C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, PD0, PD0, PD0, 5L, 10L);
-               C2F(dr)("xliness","str",polyx,polyy,fill,&npoly,&p ,PI0,PD0,PD0,PD0,PD0,0L,0L);
-             }
-             if(sciGetIsMark(pobj))
-               DrawMarks3D(pobj,5*npoly,polyx,polyy,DPI);
-             break;
-           }
-         }
-       } /* end SCI_SURFACE*/
-       else if(sciGetEntityType (pobj)==SCI_SEGS) { /* PSEGS here ! */
-         if (sciGetIsMark(pobj) == TRUE){
-           integer v;
-           double dv=0;
-           int x_[4], markidsizenew[2];
-           
-           x_[0] = sciGetMarkForeground(pobj);
-           
-           markidsizenew[0] = sciGetMarkStyle(pobj);
-           markidsizenew[1] = sciGetMarkSize (pobj);
-           
-           C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                     &dv, &dv, &dv, 5L, 4096);
-           C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                     &dv, &dv, &dv, &dv, 5L, 4096);
-           
-           C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                     PD0, PD0, 0L, 0L);
-           DrawNewMarks(pobj,p,polyx,polyy,DPI);
-         }
-         
-         if(sciGetIsLine(pobj)){
-           C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, 
-                     PD0, PD0, PD0, 5L, 6L);
-           C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, 
-                     PD0, PD0, PD0, 5L, 10L);
-           C2F (dr) ("xset", "thickness",  context+1, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 5L, 9L);
-           C2F (dr) ("xset", "line style", context+2, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L); 
-           C2F(dr)("xsegs","v",polyx,polyy,&p,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
-         }
-       }
-       else if(sciGetEntityType (pobj)==SCI_RECTANGLE) { /* RECTANGLE case here ! */
-         if( sciGetIsFilled(pobj) )
-           {
-             integer v;
-             double dv=0;
-             int x_[4],close=1;
-             char str[2] = "xv";
-             x_[0] = sciGetBackground(pobj);
-             
-             C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                       &dv, &dv, &dv, 5L, 4096);
-             C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                       &dv, &dv, &dv, &dv, 5L, 4096);
-             
-             C2F (dr) ("xarea", str, &p, polyx, polyy, &close, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-           }
-         
-         if (sciGetIsMark(pobj) == TRUE){
-           integer v;
-           double dv=0;
-           int x_[4], markidsizenew[2];
-           
-           x_[0] = sciGetMarkForeground(pobj);
-           
-           markidsizenew[0] = sciGetMarkStyle(pobj);
-           markidsizenew[1] = sciGetMarkSize (pobj);
-           
-           C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                     &dv, &dv, &dv, 5L, 4096);
-           C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                     &dv, &dv, &dv, &dv, 5L, 4096);
-           
-           C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                     PD0, PD0, 0L, 0L);
-           DrawNewMarks(pobj,p,polyx,polyy,DPI);
-         }
-         
-         if(sciGetIsLine(pobj)){
-           C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, 
-                     PD0, PD0, PD0, 5L, 6L);
-           C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, 
-                     PD0, PD0, PD0, 5L, 10L);
-           C2F (dr) ("xset", "thickness",  context+1, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 5L, 9L);
-           C2F (dr) ("xset", "line style", context+2, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L); 
-           C2F(dr)("xsegs","v",polyx,polyy,&p,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
-         }
-       }
-       else { /* POLYLINE case starts here ! */
-         /* special case 5 */
-         if(sciGetIsFilled(pobj) == TRUE && pPOLYLINE_FEATURE (pobj)->plot != 5) /* No filling if mode plot == 5 is selected */
-           {
-             integer v;
-             double dv=0;
-             int x_[4],close=1;
-             char str[2] = "xv";
-             x_[0] = sciGetBackground(pobj);
-             
-             C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                       &dv, &dv, &dv, 5L, 4096);
-             C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                       &dv, &dv, &dv, &dv, 5L, 4096);
-             
-             C2F (dr) ("xarea", str, &p, polyx, polyy, &close, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-           }
-         
-         if (sciGetIsMark(pobj) == TRUE){
-           integer v;
-           double dv=0;
-           int x_[4], markidsizenew[2];
-           
-           x_[0] = sciGetMarkForeground(pobj);
-           
-           markidsizenew[0] = sciGetMarkStyle(pobj);
-           markidsizenew[1] = sciGetMarkSize (pobj);
-           
-           C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                     &dv, &dv, &dv, 5L, 4096);
-           C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                     &dv, &dv, &dv, &dv, 5L, 4096);
-           
-           C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                     PD0, PD0, 0L, 0L);
-           DrawNewMarks(pobj,p,polyx,polyy,DPI);
-         }
-         
-         if(sciGetIsLine(pobj)){
-           int un = 1, deux = 2;
-           context[3] = 0;
-           
-           C2F (dr) ("xset", "dashes",     context,   context,   context+3, context+3, context+3, PI0, PD0, 
-                     PD0, PD0, PD0, 5L, 6L);
-           C2F (dr) ("xset", "foreground", context,   context,   context+3, context+3, context+3, PI0, PD0, 
-                     PD0, PD0, PD0, 5L, 10L);
-           C2F (dr) ("xset", "thickness",  context+1, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 5L, 9L);
-           C2F (dr) ("xset", "line style", context+2, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L);
-           C2F (dr) ("xlines", "xv", &deux, polyx, polyy, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-         }
-       }
-      }
-    }
-
-#ifdef _MSC_VER
-       if ( hdcflag == 1) ReleaseWinHdc ();
-#endif   
-       
-  }
-  FREE(dist);FREE(locindex);FREE(polyx);FREE(polyy);
-  FREE(verticesX) ;
-  FREE(verticesY) ;
-  FREE(verticesZ) ;
-}
-
-/*------------------------------------------------------------------------------------------*/
-/**
- * draw the figure number numFigure.
- */
-void sciDrawFigure( int numFigure )
-{
-  int curFigure = sciGetNumFigure( sciGetCurrentFigure() ) ;
-  sciSetUsedWindow( numFigure ) ;
-  sciDrawObj( sciGetCurrentFigure() ) ;
-  sciSetUsedWindow( curFigure ) ;
-}
-/*------------------------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------------------------*/
-/* sciRefreshObj                                                                             */
-/* draw an object but before select the rigth figure for display                             */
-/*-------------------------------------------------------------------------------------------*/
-int sciRefreshObj( sciPointObj * pobj )
-{
-  
-  int parentId = sciGetNum( sciGetParentFigure( pobj ) ) ;
-  int currentId             ;
-  int status                ;
-  int verboseGet        = 0 ;
-  int iDontKnowWhatItIs     ;
-  /* get current Id in ScilabXgc */
-  C2F (dr) ("xget", "window",&verboseGet,&currentId,&iDontKnowWhatItIs,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-
-  /* set the parent figure of the object as the current figure */
-  if ( parentId != currentId )
-  {
-    C2F (dr) ("xset", "window",&parentId,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-  }
-  
-  /* draw the object */
-  status = sciDrawObjIfRequired( pobj ) ;
-
-  /* set back the values */
-  if ( parentId != currentId )
-  {
-    C2F (dr) ("xset", "window",&currentId,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-  }
-
-  return status ;
-  
-  
-}
-
-
-
-/**sciDrawObjIfRequired
- * Draws Object (only the basic  graphicobject under subwindows) in its SubWindow or figure
- * if and only if pFIGURE_FEATURE(pobj)->auto_redraw == TRUE !!
- * Only used inside High Level functions calls (sucha as plot2d, plot3d...)
- * @param sciPointObj * pobj: the pointer to the entity
- * @return  int 0 if OK, -1 if not
- */
-int
-sciDrawObjIfRequired (sciPointObj * pobj)
-{
-  sciPointObj * pfigure = sciGetParentFigure(pobj);
-
-  if( pFIGURE_FEATURE(pfigure)->auto_redraw && pFIGURE_FEATURE(pfigure)->visible )
-  {
-    sciDrawObj(pobj);
-  }
-
-  return 0;
-}
-
-/**sciDrawObj
- * Draws Object (only the basic  graphicobject under subwindows) in its SubWindow or figure
- * @param sciPointObj * pobj: the pointer to the entity
- * @return  int 0 if OK, -1 if not
- */
-int
-sciDrawObj (sciPointObj * pobj)
-{
-  char str[2] = "xv"/*,locstr*/;
-  integer n,n1,uc,verbose=0,narg,xz[10],na,arssize,sflag=0,un=1;
-  integer *xm = NULL;
-  integer *ym = NULL;
-  integer *zm = NULL;
-  integer n2 = 1, xtmp[4], ytmp[4], *pstyle = NULL/*,rect1[4]*/;
-  integer closeflag = 0 ;
-  double w2,h2 ;
-  double xx[2],yy[2];   
-  integer px1[2],py1[2],pn1=1,pn2=2;
-  integer nn1,nn2, arsize,lstyle,iflag;
-  double arsize1=5.0,arsize2=5.0,dv;
-  integer angle1, angle2;
-  integer x1, yy1, w1, h1, wstr,hstr/*,hh1*/;
-  integer x[6], v;
-  integer xold[5], vold = 0, flagx = 0;
-  sciSons *psonstmp;
-  integer itmp[5];
-  integer markidsizeold[2], markidsizenew[2];
-  sciPointObj /* *psubwin, */ *currentsubwin;
-  /*   double locx,locy,loctit; */
-  char logflags[4];
-  double xbox[8],ybox[8],zbox[8];
-  double *xzz = NULL;
-  double *yzz = NULL;
-  double *zzz = NULL;
-  static integer InsideU[4],InsideD[4];
-       
-  integer xxx[6];
-  int fontstyle_zero = 0; /*To fill Sci_Axis for Axes objects */
-  integer isoflag =0;     /*  for 3d isoview mode*/
-
-  sciSurface * ppsurface = NULL; /* debug */
-  sciAxes *paxes = (sciAxes *) NULL; /* debug */
-  /*   sciPointObj * pfigure = NULL;  sciPointObj * psubwin = NULL;/\* debug *\/  */
-  sciSubWindow * ppsubwin = NULL; /* debug */
-  int i,j;
-  /* variable pour le set_scale update_frame_bounds*/
-  double subwin[4], framevalues[4];
-
-  int nb_curves = 0, *curves_size = NULL, jk; /* for SCI_POLYLINE */
-  double **xvect = (double **) NULL;
-  double **yvect = (double **) NULL;
-  double **zvect = (double **) NULL;
-  int result_trans3d = 1;
-  BOOL drawline = TRUE;
-  int nb_curves_bar = 0;
-  
-  double bar_width = 0.;
-  double * x_shift = NULL;
-  double * y_shift = NULL;
-  double * z_shift = NULL;
-  double tempvect = 0.;
-
-  /* get the number of curves/polylines created */
-  /* by ONE call to plot2d (property pPOLYLINE_FEATURE ->n2) */
-  /* to help the drawing of the bar (case 6 ONLY) in case POLYLINE */
-  
-  char STRFLAG[4];
-  int DPI[2];
-
-/*   int nb_vertices=0; */
-
-  subwin[0]    = 0;
-  subwin[1]    = 0;
-  subwin[2]   = 1;
-  subwin[3]    = 1;
-  framevalues[0] = 0;
-  framevalues[1] = 0;
-  framevalues[2] = 1;
-  framevalues[3] = 1;
-  
-  /* driver test */
-  
-  if((GetDriverId() != 0) && ( isGraphicSessionOpened() )){
-    /*     printf("I DO NOTHING !!\n"); */
-    return -1;
-  }
-
-  currentsubwin = (sciPointObj *)sciGetSelectedSubWin (sciGetCurrentFigure ());
-
-  /* get the DPI of the current driver to draw new marks correctly */
-  GetDPIFromDriver(DPI);
-
-  switch (sciGetEntityType (pobj))
-    {
-    case SCI_FIGURE:
-    {
-      sciFigure * ppFigure = pFIGURE_FEATURE(pobj) ;
-      int curWinNum = 0 ;
-      if( !ppFigure->auto_redraw )
-      {
-        break ;
-      }
-      
-      x[1] = sciGetBackground (pobj) ;
-      x[4] = 0 ;
-      /** xclear will properly upgrade background if necessary **/
-#ifdef _MSC_VER
-      flag_DO = MaybeSetWinhdc() ;
-#endif
-      
-      /* select the right figure for drawing to avoid displaying in a wrong window */
-      C2F(dr)("xget","window",&verbose,&curWinNum,&narg,PI0,PI0,PI0,&dv,&dv,&dv,&dv,5L,7L);
-      C2F(dr)("xset","window",&(ppFigure->number),PI0,PI0,PI0,PI0,PI0,&dv,&dv,&dv,&dv,5L,7L);
-      
-      C2F(dr)("xset","pixmap",&(ppFigure->pixmap),PI0,PI0,PI0,PI0,PI0,PD0,
-             PD0,PD0,PD0,0L,0L);
-      if (pFIGURE_FEATURE (pobj)->pixmap == 0 || GetDriverId() != 0){
-       /* Change background BEFORE xclear F.Leray */
-       C2F(dr)("xset","background",&x[1],PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,5L,7L); 
-       C2F (dr) ("xclear", "v", PI0, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0,0L, 0L);
-      }
-      else
-       C2F (dr) ("xset","wwpc", PI0, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0,0L, 0L);
-
-      C2F(dr)("xset","background",&x[1],PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,5L,7L); /* Change background F.Leray*/
-      C2F(dr)("xset","alufunction",&(sciGetScilabXgc (pobj)->CurDrawFunction),PI0,PI0,PI0,
-             PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-#ifdef _MSC_VER
-      if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-
-      /* STOP HERE if figure is invisible: */
-      if ( !sciGetVisibility(pobj) ) { break; }
-
-      psonstmp = sciGetLastSons (pobj);
-      while (psonstmp != (sciSons *) NULL) {
-       if (sciGetEntityType (psonstmp->pointobj) == SCI_SUBWIN) sciDrawObj (psonstmp->pointobj);
-       
-       psonstmp = psonstmp->pprev;
-      }
-      
-      /* return to the current window */
-      C2F(dr)("xset","window",&curWinNum,PI0,PI0,PI0,PI0,PI0,&dv,&dv,&dv,&dv,5L,7L);
-      break;
-    }
-    case SCI_SUBWIN: 
-      if ( !sciGetVisibility(pobj) ) { break; }
-
-      ppsubwin = pSUBWIN_FEATURE (pobj);
-
-      sciSetSelectedSubWin(pobj); 
-     
-      set_scale ("tttftt", ppsubwin->WRect, ppsubwin->FRect,
-                NULL, ppsubwin->logflags, 
-                ppsubwin->ARect); 
-
-      if (ppsubwin->is3d) 
-       {  
-         /* to avoid re-drawing on screen during computation of the vertices (at least)... */
-         /* see zoom_box function in Plo2dEch.c*/
-         if(GlobalFlag_Zoom3dOn == 1)
-           {
-             int un2=1;
-             C2F(dr)("xset","pixmap",&un2,PI0,PI0,PI0,PI0,PI0,PD0,
-                     PD0,PD0,PD0,0L,0L);
-             C2F (dr) ("xset","wwpc", PI0, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0,0L, 0L);
-           }
-         
-         /* 3D Coordinates */ /* verifier si c'est encore utile SS */
-         /*To have directly all the possible ISOVIEW Modes*/
-         isoflag = (long)(ppsubwin->axes.flag[1]+1)/2; 
-        
-         if(ppsubwin->isoview == TRUE) {
-           if(isoflag ==2 || isoflag == 3){            }
-           else {
-             if((ppsubwin->axes.flag[1] == 0)
-                || (ppsubwin->axes.flag[1] == 2))
-               /* The default isoview mode is type=4 3d isometric bounds 
-                  derived from the data, to similarily type=2  */
-               ppsubwin->axes.flag[1] = 4; 
-             else if(ppsubwin->axes.flag[1] == 1)
-               ppsubwin->axes.flag[1] = 3;
-           }
-         }
-         else {
-           if((ppsubwin->axes.flag[1] == 3) 
-              || (ppsubwin->axes.flag[1] == 5))
-             ppsubwin->axes.flag[1] = 1; /* computed from ebox*/
-           else if((ppsubwin->axes.flag[1] == 4) 
-                   || (ppsubwin->axes.flag[1] == 6))
-             /* The default NON-isoview mode is 2 computed from data*/
-             ppsubwin->axes.flag[1] = 2; 
-         }
-        
-         axis_3ddraw(pobj,xbox,ybox,zbox,InsideU,InsideD); /* TEST on sciGetVisibility inside : REMOVED F.Leray 21.01.05 */
-         /* because axis_3ddraw displays 3d axes BUT ALSO compute + reset the 3d scale BEFORE !! */
-         
-          /* merge object is drawn first  since it might conceal other objects */
-          /* which are not merged. */
-          if ( pSUBWIN_FEATURE(pobj)->facetmerge )
-          {
-            sciDrawObj( sciGetMerge( pobj ) ) ;
-          }
-
-          psonstmp = sciGetLastSons (pobj);
-          while (psonstmp != (sciSons *) NULL)
-          {
-            if ( !(pSUBWIN_FEATURE(pobj)->facetmerge && sciIsMergeable(psonstmp->pointobj))  )
-            {
-              sciDrawObj(psonstmp->pointobj) ;
-            }
-            psonstmp = psonstmp->pprev;
-          }
-
-         triedre(pobj,xbox,ybox,zbox,InsideU,InsideD);
-        
-         wininfo("alpha=%.1f,theta=%.1f",ppsubwin->alpha,ppsubwin->theta); 
-       }/***/
-      else /* we are in 2D mode...*/
-       {
-         x[0] = sciGetForeground (pobj);
-         x[2] = sciGetLineWidth (pobj);
-         x[3] = sciGetLineStyle (pobj);
-         markidsizenew[0] = sciGetMarkStyle(pobj);
-         markidsizenew[1] = sciGetLineWidth (pobj);x[4] = 0;v = 0;dv = 0;
-        
-#ifdef _MSC_VER
-         flag_DO=MaybeSetWinhdc();
-#endif
-         C2F (dr) ("xset","dashes",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
-         C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
-         C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-         C2F (dr) ("xset","mark",&markidsizenew[0],&markidsizenew[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-        
-         sci_update_frame_bounds_2d(pobj);
-        
-         
-         /* Clipping only exists in 2d */
-         /* the global var. Cscale has just been updated */
-         /* therefore I can re-compute the clipping now (if it is "clipgrf") */
-         
-         sciClip(pobj); /* to update the clip_box if needed */
-         sciUnClip(pobj);
-         
-         DrawAxesBackground();
-          
-          drawAxesGrid( pobj ) ;
-
-          /* there is a bug here */
-          /* We should make a check for merge objects here */
-          /* But merge object has been only created only for 3d */
-          /* so sometimes it works, sometime not */
-          psonstmp = sciGetLastSons (pobj);
-          while (psonstmp != (sciSons *) NULL)
-          {
-            sciDrawObj(psonstmp->pointobj) ; 
-            psonstmp = psonstmp->pprev;
-          }      
-
-         x[0] = sciGetForeground (pobj);
-         x[2] = sciGetLineWidth (pobj);
-         x[3] = sciGetLineStyle (pobj);
-         markidsizenew[0] = sciGetMarkStyle(pobj);
-         markidsizenew[1] = sciGetLineWidth (pobj);x[4] = 0;v = 0;dv = 0;
-        
-         /* F.Leray 07.12.04 */
-         /* TO CORRECT the bug 1115 : Big object (grayplots) could cover axes*/
-         C2F (dr) ("xset","dashes",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
-         C2F (dr) ("xset","foreground",x,x,x+4,x+4,x+4,&v,&dv,&dv,&dv,&dv,5L,4096);
-         C2F (dr) ("xset","thickness",x+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-         C2F (dr) ("xset","mark",&markidsizenew[0],&markidsizenew[1],PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-         
-         rebuild_strflag(pobj,STRFLAG);
-         axis_draw2 (STRFLAG);
-         
-         labels2D_draw(pobj); /* F.Leray 08.08.05 : labels' drawing at the end */
-         
-#ifdef _MSC_VER
-         if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-         wininfo("");  
-       }
-      break ;
-      /******************/
-
-    case SCI_AGREG:
-    {
-
-      BOOL isMerging = pSUBWIN_FEATURE (sciGetParentSubwin(pobj) )->facetmerge ;
-      if (!sciGetVisibility(pobj)) break; /* RE-PUT F.Leray 21.01.05 */
-      /* scan the hierarchie and call sciDrawObj */
-      psonstmp = sciGetLastSons(pobj) ;
-      while (psonstmp != (sciSons *) NULL)
-      {
-        /* draw only objects which are not already included in a merge objects */
-        if ( !isMerging || !sciIsMergeable(psonstmp->pointobj) )
-        {
-          sciDrawObj (psonstmp->pointobj);
-        }
-        psonstmp = psonstmp->pprev;
-      }
-      break;
-      /************ 30/04/2001 **************************************************/
-    }    
-    case SCI_LEGEND: 
-      if (!sciGetVisibility(pobj)) break;
-      else
-       {
-               sciLegend * ppLegend = pLEGEND_FEATURE (pobj) ;
-       /* sciSetCurrentObj (pobj);     F.Leray 25.03.04*/
-       C2F (dr1) ("xget", "dashes", &flagx, &xold[0], &vold, &vold, &vold,
-                &vold, &dv, &dv, &dv, &dv, 5L, 4096);
-       C2F (dr1) ("xget", "foreground", &flagx, &xold[1], &vold, &vold, &vold,
-                &vold, &dv, &dv, &dv, &dv, 5L, 4096);
-      
-      
-       itmp[0] = 0;            /* verbose */
-       itmp[1] = 0;            /* thickness value*/
-       itmp[2] = 1;            /* narg*/
-       C2F (dr) ("xget", "thickness", &itmp[0], &itmp[1], &itmp[2], PI0, PI0,
-                       PI0, PD0, PD0, PD0, PD0, 0L, 0L);
-       C2F (dr) ("xget", "mark", &itmp[0], markidsizeold, &itmp[3], PI0, PI0, PI0,
-                       PD0, PD0, PD0, PD0, 0L, 0L);
-
-       /* load the object foreground and dashes color */
-       x[0] = sciGetForeground (pobj); /*la dash est de la meme couleur que le foreground*/
-       x[4] = 0;
-       v = 0;
-       dv = 0;
-
-       xxx[0] = sciGetFontForeground (pobj);/*la dash est de la meme couleur que le foreground*/
-       xxx[2] = sciGetFontDeciWidth (pobj)/100;
-       xxx[3] = 0;
-       xxx[4] = sciGetFontStyle(pobj);
-      
-#ifdef _MSC_VER 
-       flag_DO=MaybeSetWinhdc();
-#endif
-       C2F (dr1) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                        &dv, &dv, &dv, 5L, 4096);
-       C2F (dr1) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                        &dv, &dv, &dv, &dv, 5L, 4096);
-
-       C2F(dr)("xset","font",xxx+4,xxx+2,&v, &v, &v, &v,&dv, &dv, &dv, &dv, 5L, 4L); /* Adding F.Leray*/
-
-
-       /*permet la mise a jour des legendes correspondantes aux entites associees */
-       for (i = 0; i < ppLegend->nblegends; i++)
-       {
-          if (sciGetIsMark(pLEGEND_FEATURE (pobj)->pptabofpointobj[i]))
-          {
-            pLEGEND_FEATURE (pobj)->pstyle[i] = 
-              -sciGetMarkStyle (pLEGEND_FEATURE (pobj)->pptabofpointobj[i]);
-          }
-          else
-          {
-            ppLegend->pstyle[i] =  
-              sciGetForeground( ppLegend->pptabofpointobj[i] );
-          }
-       }
-       /*sciSetCurrentObj(pobj); F.Leray 25.03.04*/
-       Legends( ppLegend->pstyle, &(ppLegend->nblegends), getStrMatElement(sciGetText(pobj),0,0));
-       
-          
-       /* restore the graphic context */
-
-       C2F (dr1) ("xset", "dashes", &xold[0], &vold, &vold, &vold, &vold, &v,
-                        &dv, &dv, &dv, &dv, 5L, 6L);
-       C2F (dr1) ("xset", "foreground", &xold[1], &vold, &vold, &vold, &vold,
-                        &v, &dv, &dv, &dv, &dv, 5L, 10L);
-#ifdef _MSC_VER 
-       if ( flag_DO == 1) ReleaseWinHdc ();
-#endif
-       }
-      break; 
-
-      /******************************** 22/05/2002 ***************************/    
-    case SCI_FEC:
-    {
-      int curLineStyle = 0 ;
-      int lineStyle    = 1 ;
-      int verbose_      = 0 ;
-
-      if ( ! sciGetVisibility(pobj) ) { break; }
-      
-      n1=1;
-      if ((xm = MALLOC ((pFEC_FEATURE (pobj)->Nnode)*sizeof (integer))) == NULL) { return -1 ; }
-      if ((ym = MALLOC ((pFEC_FEATURE (pobj)->Nnode)*sizeof (integer))) == NULL) { return -1 ; }
-
-      if( !pSUBWIN_FEATURE(sciGetParentSubwin(pobj))->is3d )
-       {
-         for ( i =0 ; i < pFEC_FEATURE (pobj)->Nnode ; i++)
-          {
-           xm[i]= XScale(pFEC_FEATURE (pobj)->pvecx[i]); 
-           ym[i]= YScale(pFEC_FEATURE (pobj)->pvecy[i]);
-          } 
-       }
-      else /* 3D version */
-       {
-         double * xvect_ = NULL;
-         double * yvect_ = NULL;
-         int nbNode = pFEC_FEATURE (pobj)->Nnode;
-         
-
-         if ((xvect_ = MALLOC ( nbNode * sizeof (double))) == NULL) return -1;
-         if ((yvect_ = MALLOC ( nbNode * sizeof (double))) == NULL){
-           FREE(xvect_); xvect_ = (double *) NULL; return -1;
-         }
-         
-         for( i = 0 ; i < nbNode ; i++ )
-          {
-           xvect_[i] = pFEC_FEATURE (pobj)->pvecx[i];
-           yvect_[i] = pFEC_FEATURE (pobj)->pvecy[i];
-         }
-         
-         ReverseDataFor3DXonly( sciGetParentSubwin(pobj), xvect_, nbNode ) ;
-         ReverseDataFor3DYonly( sciGetParentSubwin(pobj), yvect_, nbNode ) ;
-         
-         trans3d( sciGetParentSubwin(pobj), nbNode, xm, ym, xvect_, yvect_, NULL ) ;
-
-         FREE(xvect_); xvect_ = (double *) NULL;
-         FREE(yvect_); yvect_ = (double *) NULL;
-       }
-
-#ifdef _MSC_VER
-      flag_DO=MaybeSetWinhdc();
-#endif
-      /* need to put line style to plain otherwise bug 1872 occurs */
-      C2F(dr)("xget","line style",&verbose_,&curLineStyle,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      C2F(dr)("xset", "line style", &lineStyle, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L);
-
-      newfec(xm,ym,pFEC_FEATURE (pobj)->pnoeud,pFEC_FEATURE (pobj)->pfun,
-            &pFEC_FEATURE (pobj)->Nnode,&pFEC_FEATURE (pobj)->Ntr,
-            pFEC_FEATURE (pobj)->zminmax,pFEC_FEATURE (pobj)->colminmax,
-            pFEC_FEATURE (pobj)->colout, pFEC_FEATURE (pobj)->with_mesh);
-
-      C2F(dr)("xset", "line style", &curLineStyle, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L);
-
-#ifdef _MSC_VER
-      if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-         
-      /* FREE(xm);FREE(ym); */ /* SS 02/04 */
-      FREE(xm); xm = (integer *) NULL;
-      FREE(ym); ym = (integer *) NULL; /* et F.Leray 18.02.04*/
-
-      break;      
-      /******************************** 22/05/2002 ***************************/
-    }
-    case SCI_SEGS:
-      if (!sciGetVisibility(pobj)) break;
-      
-      sciClip(pobj);
-
-      /* load the object foreground and dashes color */
-      x[0] = sciGetForeground(pobj); /* Adding F.leray 27.04.04 */
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = sciGetLineStyle (pobj);
-      x[4] = 0;
-      markidsizenew[0] =  sciGetMarkStyle(pobj);;
-      markidsizenew[1] =  sciGetLineWidth (pobj);;
-
-#ifdef _MSC_VER 
-      flag_DO=MaybeSetWinhdc();
-#endif
-
-      C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-               &dv, &dv, &dv, 5L, 4096);
-      C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);    
-      C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);
-      C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-               PD0, PD0, 0L, 0L);
-#ifdef _MSC_VER 
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif 
-
-      if ( pSEGS_FEATURE (pobj)->ptype == 0 ) /* ptype == 0 F.Leray : This is NOT A champ */
-      {  
-
-        n=pSEGS_FEATURE (pobj)->Nbr1;
-
-        if ((xm = MALLOC (n*sizeof (integer))) == NULL)        { return -1 ; }
-        if ((ym = MALLOC (n*sizeof (integer))) == NULL)        { return -1 ; } /* F.Leray 18.02.04 Correction suivante:*/
-
-        if ((pstyle = MALLOC ((int)(n/2)*sizeof (integer))) == NULL) { return -1 ; } /* SS 19.04*/
-        if (pSEGS_FEATURE (pobj)->iflag == 1)
-        {
-          for ( i =0 ; i <(int) (n/2) ; i++)
-          {
-            pstyle[i]=sciGetGoodIndex(pobj, pSEGS_FEATURE (pobj)->pstyle[i]);
-          }
-        }
-        else
-        {
-          pstyle[0] = sciGetGoodIndex(pobj, pSEGS_FEATURE (pobj)->pstyle[0]) ;
-        }
-        if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-        {
-          double * xvect_ = NULL;
-          double * yvect_ = NULL;
-          double * zvect_ = NULL;
-
-          if ((xvect_ = MALLOC (n*sizeof (double))) == NULL) return -1;
-          if ((yvect_ = MALLOC (n*sizeof (double))) == NULL) return -1;
-
-          for( i = 0 ; i < n ; i++ )
-          {
-            xvect_[i] = pSEGS_FEATURE (pobj)->vx[i];
-            yvect_[i] = pSEGS_FEATURE (pobj)->vy[i];
-          }
-
-          if ( pSEGS_FEATURE (pobj)->vz != NULL )
-          {
-            if ((zvect_ = MALLOC (n*sizeof (double))) == NULL) { return -1 ; }
-            for( i = 0 ; i < n ; i++ )
-            {
-              zvect_[i] = pSEGS_FEATURE (pobj)->vz[i];
-            }
-          }
-
-          ReverseDataFor3D(sciGetParentSubwin(pobj),xvect_,yvect_,zvect_,n);
-
-          trans3d(sciGetParentSubwin(pobj),n,xm,ym,xvect_,yvect_,zvect_);
-
-          FREE(xvect); xvect_ = NULL;
-          FREE(yvect); yvect_ = NULL;
-          if ( zvect_ != NULL )
-          {
-            FREE( zvect_ ) ;
-            zvect_ = NULL;
-          }
-        }
-        else
-        {
-          for ( i =0 ; i < n ; i++)
-          {
-            xm[i] = XScale(pSEGS_FEATURE (pobj)->vx[i]) ; 
-            ym[i] = YScale(pSEGS_FEATURE (pobj)->vy[i]) ;
-          }
-        }
-#ifdef _MSC_VER 
-        flag_DO = MaybeSetWinhdc();
-#endif
-
-        if( sciGetIsMark(pobj) )
-        {
-          drawPolyMarks( pobj, n, xm, ym, DPI ) ;
-        }
-
-        if( sciGetIsLine( pobj ) )
-        {
-          x[0] = sciGetForeground(pobj);
-
-          C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-            &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-            PD0, PD0, PD0, 0L, 0L);    
-          C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-            PD0, PD0, PD0, 0L, 0L);
-
-          if ( pSEGS_FEATURE (pobj)->arrowsize == 0 )
-          {
-            /* only lines */
-            C2F(dr)("xsegs","v",xm,ym,&n,pstyle,&pSEGS_FEATURE (pobj)->iflag,
-              PI0,PD0,PD0,PD0,PD0,0L,0L);
-          }
-          else
-          {
-            int arrowSize = computeRealArrowSize( pobj, n, xm, ym ) ;                      
-            C2F(dr)("xarrow","v",xm,ym,&n,&arrowSize,pstyle,&pSEGS_FEATURE(pobj)->iflag,PD0,PD0,PD0,PD0,0L,0L);
-            /* with C2F(dr)("xarrow",... did not work: why? What does (dr1) routine make more than (dr) in New Graphics mode ?? */
-            /* Answer : dr deals with pixels value (data: xm and ym are integers!!) whereas dr1 deals with double value coming from the user */
-            /* This is true for old and new graphics mode. */
-          }
-
-        }
-
-
-#ifdef _MSC_VER 
-        if ( flag_DO == 1) ReleaseWinHdc ();
-#endif 
-        FREE(xm);         xm = (integer *) NULL;
-        FREE(ym);         ym = (integer *) NULL; 
-        FREE(pstyle); pstyle = (integer *) NULL; /* SS 19.04*/
-      }
-      else    /*ptype == 1*/ /* ptype == 1 F.Leray : This IS A champ */
-      {
-#ifdef _MSC_VER 
-        flag_DO = MaybeSetWinhdc();
-#endif
-        C2F(dr)("xget","use color",&verbose, &uc, &narg,&v,&v,&v,&dv,&dv,&dv,&dv,0L,0L);
-        if (uc)
-          C2F(dr)("xget","color",&verbose,xz,&narg,&v,&v,&v,&dv,&dv,&dv,&dv,0L,0L);
-        else
-          C2F(dr)("xget","line style",&verbose,xz,&narg,&v,&v,&v,&dv,&dv,&dv,&dv,0L,0L);
-#ifdef _MSC_VER 
-        if ( flag_DO == 1) ReleaseWinHdc ();
-#endif 
-
-        n=2*(pSEGS_FEATURE (pobj)->Nbr1)*((pSEGS_FEATURE (pobj)->Nbr2));
-
-
-        xm = MALLOC( n * sizeof (integer) ) ;
-        ym = MALLOC( n * sizeof (integer) ) ;
-
-        zm = NULL ; /* SS 02/04 */
-        if ( xm == NULL || ym == NULL) 
-        {
-          sciprint("Running out of memory \n");
-          return -1;
-        }      
-        if ( pSEGS_FEATURE (pobj)->typeofchamp == 1 )
-        { /* champ1 has been called */
-
-          zm = MALLOC (((int) (n/2))*sizeof (integer)) ;
-
-          if (  zm == NULL ) 
-          {
-            sciprint("Running out of memory \n");
-            return -1;
-          }      
-        }
-
-        sciChamp2DRealToPixel(xm,ym,zm,&na,&arssize,
-          pSEGS_FEATURE (pobj)->vx,pSEGS_FEATURE (pobj)->vy,pSEGS_FEATURE (pobj)->vfx,
-          pSEGS_FEATURE (pobj)->vfy,&(pSEGS_FEATURE (pobj)->Nbr1),
-          &(pSEGS_FEATURE (pobj)->Nbr2),&(pSEGS_FEATURE (pobj)->parfact),&(pSEGS_FEATURE (pobj)->typeofchamp), FALSE ) ;
-#ifdef _MSC_VER 
-        flag_DO = MaybeSetWinhdc();
-#endif
-
-        /** size of arrow **/
-        /* a bit tricky */
-
-        /* test if we are in 3d HERE */
-        if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-        {
-          double * xvect_ = NULL;
-          double * yvect_ = NULL;
-          double * zvect_ = NULL;
-
-          if ((xvect_ = MALLOC (n*sizeof (double))) == NULL) return -1;
-          if ((yvect_ = MALLOC (n*sizeof (double))) == NULL) return -1;
-          if ((zvect_ = MALLOC (n*sizeof (double))) == NULL) return -1;
-
-          for(i=0;i<n;i++){
-            xvect_[i] = XPi2R(xm[i]);
-            yvect_[i] = YPi2R(ym[i]);
-          }
-
-
-          /* F.Leray 06.12.04 */
-          /* A REVOIR : ne marche pas en 3D */
-          ReverseDataFor3D(sciGetParentSubwin(pobj),xvect_,yvect_,NULL,n);
-
-          trans3d(sciGetParentSubwin(pobj),n,xm,ym,xvect_,yvect_,NULL);
-
-          FREE(xvect_); xvect_ = NULL;
-          FREE(yvect_); yvect_ = NULL;
-          FREE(zvect_); zvect_ = NULL;
-        }
-
-        if ( sciGetIsMark( pobj ) )
-        {
-          drawPolyMarks( pobj, n, xm, ym, DPI ) ;
-        }
-
-        if( sciGetIsLine( pobj ) )
-        {
-          int arrowSize =  computeRealArrowSize( pobj, na, xm, ym ) ;
-          x[0] = sciGetForeground(pobj);
-
-          C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-            &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-            PD0, PD0, PD0, 0L, 0L);    
-          C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-            PD0, PD0, PD0, 0L, 0L);
-          if( pSEGS_FEATURE(pobj)->typeofchamp == 0 )
-          {
-            C2F(dr)("xarrow","v",xm,ym,&na,&arrowSize,xz,(sflag=0,&sflag),&dv,&dv,&dv,&dv,0L,0L);
-          }
-          else
-          {
-            C2F(dr)("xarrow","v",xm,ym,&na,&arrowSize,zm,(sflag=1,&sflag),&dv,&dv,&dv,&dv,0L,0L);
-          }
-        }
-
-
-#ifdef _MSC_VER 
-        if ( flag_DO == 1) ReleaseWinHdc ();
-#endif 
-        FREE(xm) ; xm = (integer *) NULL;
-        FREE(ym) ; ym = (integer *) NULL;/* SS 02/04 */ /* et F.Leray 18.02.04*/
-        if ( pSEGS_FEATURE (pobj)->typeofchamp == 1) 
-        {
-          FREE(zm); zm = (integer *) NULL;/* F.Leray 1802.04 modif ici*/
-        }
-      }  
-
-      sciUnClip(pobj);
-      break;
-    case SCI_GRAYPLOT:
-      if (!sciGetVisibility(pobj)) break;
-      n1 = pGRAYPLOT_FEATURE (pobj)->nx;
-      n2 = pGRAYPLOT_FEATURE (pobj)->ny;    
-     
-      switch (pGRAYPLOT_FEATURE (pobj)->type )
-       {
-       
-         
-       case 0:  /* Grayplot case */
-         if(pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d == FALSE){
-
-           /* F.Leray 19.05.05 : Now I use only xliness (not xfrect) */
-           /* to better manage axes reversing */
-           if ((xm = MALLOC (n1*n2*sizeof (integer))) == NULL) return -1;
-           if ((ym = MALLOC (n2*n1*sizeof (integer))) == NULL){
-             FREE(xm); xm = (integer *) NULL; return -1; 
-           }
-
-           for ( i =0 ; i < n1 ; i++)  /* on x*/
-             for ( j =0 ; j < n2 ; j++)  /* on y */
-               {
-                 xm[i+j*n1]= XScale(pGRAYPLOT_FEATURE (pobj)->pvecx[i]);
-                 ym[j+i*n2]= YScale(pGRAYPLOT_FEATURE (pobj)->pvecy[j]);
-               }
-           
-#ifdef _MSC_VER
-           flag_DO = MaybeSetWinhdc();
-#endif
-           frame_clip_on();
-  
-           if (strncmp(pGRAYPLOT_FEATURE (pobj)->datamapping,"scaled", 6) == 0)
-             GraySquareScaled(xm,ym,pGRAYPLOT_FEATURE (pobj)->pvecz,n1,n2); /* SS 03/01/03 */
-           else
-             GraySquareDirect(xm,ym,pGRAYPLOT_FEATURE (pobj)->pvecz,n1,n2);
-
-           frame_clip_off();
-#ifdef _MSC_VER
-           if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-           
-           /*  FREE(xm);FREE(ym); */ /* SS 03/01/03 */
-           FREE(xm); xm = (integer *) NULL; /* F.Leray c'est mieux.*/
-           FREE(ym); ym = (integer *) NULL;
-
-         }
-         else{
-           /*3D version */
-           double * xvect_ = NULL;
-           double * yvect_ = NULL;
-       
-           if ((xvect_ = MALLOC (n1*sizeof (double))) == NULL) return -1;
-           if ((yvect_ = MALLOC (n2*sizeof (double))) == NULL){
-             FREE(xvect_); xvect_ = (double *) NULL; return -1;
-           }
-           
-           for(i=0;i<n1;i++) xvect_[i] = pGRAYPLOT_FEATURE (pobj)->pvecx[i];
-           for(i=0;i<n2;i++) yvect_[i] = pGRAYPLOT_FEATURE (pobj)->pvecy[i];
-
-
-           if ((xm = MALLOC (n1*n2*sizeof (integer))) == NULL) return -1;
-           if ((ym = MALLOC (n2*n1*sizeof (integer))) == NULL){
-             FREE(xm); xm = (integer *) NULL; return -1; 
-           }
-           
-           ReverseDataFor3DXonly(sciGetParentSubwin(pobj),xvect_,n1);
-           ReverseDataFor3DYonly(sciGetParentSubwin(pobj),yvect_,n2);
-
-           for ( i =0 ; i < n1 ; i++)  /* on x*/
-             for ( j =0 ; j < n2 ; j++)  /* on y */
-               trans3d(sciGetParentSubwin(pobj),1,&xm[i+j*n1],&ym[j+i*n2],
-                       &xvect_[i],&yvect_[j],NULL);
-           
-#ifdef _MSC_VER
-           flag_DO = MaybeSetWinhdc();
-#endif
-           frame_clip_on(); 
-           
-           /* draw the filled projected rectangle */
-           /*   for(i=0;i<(n1-1)*(n2-1);i++) */
-           /*        { */
-           for (i = 0 ; i < (n1)-1 ; i++)
-                 {
-             for (j = 0 ; j < (n2)-1 ; j++)
-               {
-                 integer vertexx[5], vertexy[5];
-                 int cinq = 5, un_ = 1;
-                 double zmoy,zmax,zmin,zmaxmin;
-                 integer verbose_=0,whiteid,narg_,fill[1],cpat,xz_[2];
-                 double *z = pGRAYPLOT_FEATURE (pobj)->pvecz;
-                 zmin=Mini(z,(n1)*(n2));
-                 zmax=Maxi(z,(n1)*(n2));
-                 zmaxmin=zmax-zmin;
-                 
-                 if (zmaxmin <= SMDOUBLE) zmaxmin=SMDOUBLE;
-                 C2F(dr)("xget","lastpattern",&verbose_,&whiteid,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-                 C2F(dr)("xget","pattern",&verbose_,&cpat,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-                 C2F(dr)("xget","wdim",&verbose_,xz_,&narg_, PI0, PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-                 
-
-                 if(strncmp(pGRAYPLOT_FEATURE (pobj)->datamapping,"scaled", 6) == 0)
-                   {
-                     /* color for current rectangle */
-                     zmoy=1/4.0*(z[i+n1*j]+z[i+n1*(j+1)]+z[i+1+n1*j]+z[i+1+n1*(j+1)]);
-                     
-                     fill[0]=1 + inint((whiteid-1)*(zmoy-zmin)/(zmaxmin));  
-                     
-                     fill[0] = - fill[0]; /* not to have contour with foreground color around the rectangle */
-                   }
-                 else /* "direct" mode is used */
-                   {
-                     fill[0] = - (int) z[j+n1*i];
-                   }
-                 
-                 vertexx[0] = xm[i+n1*j];
-                 vertexx[1] = xm[i+n1*(j+1)];
-                 vertexx[2] = xm[i+1+n1*(j+1)];
-                 vertexx[3] = xm[i+1+n1*j];
-                 vertexx[4] = xm[i+n1*j];
-                 
-                 vertexy[0] = ym[j+n2*i];
-                 vertexy[1] = ym[j+1+n2*i];
-                 vertexy[2] = ym[j+1+n2*(i+1)];
-                 vertexy[3] = ym[j+n2*(i+1)];
-                 vertexy[4] = ym[j+n2*i];
-                 
-                 C2F(dr)("xliness","str",vertexx,vertexy,fill,&un_,&cinq,
-                         PI0,PD0,PD0,PD0,PD0,0L,0L);
-               }
-               }
-           
-           frame_clip_off();  
-#ifdef _MSC_VER
-           if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-           
-           FREE(xm); xm = (integer *) NULL;
-           FREE(ym); ym = (integer *) NULL;
-           FREE(xvect_); xvect_ = (double *) NULL;
-           FREE(yvect_); yvect_ = (double *) NULL;
-         }
-         break;
-       case 1: /* Matplot case */
-         {
-           /* In this case (and inside Matplot1 too but Matplot and Matplot1 are almost the same), */
-           /* dim x = n2 and dim y = n1 (cf. scimatplot in matdes.c) */ /* F.Leray 20.05.05 */
-           sciPointObj * psubwin = sciGetParentSubwin(pobj);
-           sciSubWindow * ppsubwin_ = pSUBWIN_FEATURE (psubwin);
-           
-           if(pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d == FALSE){
-             if ((xm = MALLOC (n2*sizeof (integer))) == NULL) 
-               return -1;
-             if ((ym = MALLOC (n1*sizeof (integer))) == NULL){
-               FREE(xm);xm = (integer *) NULL; return -1;  /* F.Leray Rajout de xm = (integer *) NULL; 18.02.04*/
-             }
-            
-             for ( j =0 ; j < n2 ; j++) xm[j]= XScale(j+0.5);
-             for ( j =0 ; j < n1 ; j++) ym[j]= YScale(((n1-1)-j+0.5));
-#ifdef _MSC_VER
-             flag_DO = MaybeSetWinhdc();
-#endif
-             frame_clip_on(); 
-             if(ppsubwin_->axes.reverse[0] == TRUE || ppsubwin_->axes.reverse[1] == TRUE)
-               GraySquare1_NGreverse(xm,ym,pGRAYPLOT_FEATURE (pobj)->pvecz,n1,n2,psubwin);  
-             else
-               GraySquare1(xm,ym,pGRAYPLOT_FEATURE (pobj)->pvecz,n1,n2);  
-             frame_clip_off();  
-             /*              C2F(dr)("xrect","v",&Cscale.WIRect1[0],&Cscale.WIRect1[1],&Cscale.WIRect1[2],
-                             &Cscale.WIRect1[3],PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);*/
-#ifdef _MSC_VER
-             if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-            
-             /*  FREE(xm);FREE(ym); */ /* SS 03/01/03 */
-             FREE(xm); xm = (integer *) NULL; /* F.Leray c'est mieux.*/
-             FREE(ym); ym = (integer *) NULL;
-           }
-           else{
-             /* 3D version */
-             double * xvect_ = NULL;
-             double * yvect_ = NULL;
-          
-             /* Warning here (Matplot case) : n1 becomes n2 and vice versa */
-             if ((xvect_ = MALLOC (n2*sizeof (double))) == NULL) return -1;
-             if ((yvect_ = MALLOC (n1*sizeof (double))) == NULL){
-               FREE(xvect_); xvect_ = (double *) NULL; return -1;
-             }
-           
-             for(i=0;i<n2;i++) xvect_[i] = i+0.5;
-             for(i=0;i<n1;i++) yvect_[i] = n1-1-i+0.5;
-           
-
-             if ((xm = MALLOC (n2*n1*sizeof (integer))) == NULL)       return -1;
-             if ((ym = MALLOC (n1*n2*sizeof (integer))) == NULL){
-               FREE(xm); xm = (integer *) NULL; return -1; 
-             }
-           
-             ReverseDataFor3DXonly(sciGetParentSubwin(pobj),xvect_,n2);
-             ReverseDataFor3DYonly(sciGetParentSubwin(pobj),yvect_,n1);
-
-           
-             for ( i =0 ; i < n2 ; i++)  /* on x*/
-               for ( j =0 ; j < n1 ; j++)  /* on y */
-                 trans3d(sciGetParentSubwin(pobj),1,&xm[i+j*n2],&ym[j+i*n1],
-                         &xvect_[i],&yvect_[j],NULL);
-           
-#ifdef _MSC_VER
-             flag_DO = MaybeSetWinhdc();
-#endif
-             frame_clip_on(); 
-           
-             /* draw the filled projected rectangle */
-             /*   for(i=0;i<(n1-1)*(n2-1);i++) */
-             /*              { */
-             for (i = 0 ; i < (n2)-1 ; i++)
-               for (j = 0 ; j < (n1)-1 ; j++)
-                 {
-                   integer vertexx[5], vertexy[5];
-                   int cinq = 5, un_ = 1;
-                   integer fill;
-
-                   fill = (int ) - pGRAYPLOT_FEATURE (pobj)->pvecz[(n1-1)*i+j];
-
-                   vertexx[0] = xm[i+n2*j];
-                   vertexx[1] = xm[i+n2*(j+1)];
-                   vertexx[2] = xm[i+1+n2*(j+1)];
-                   vertexx[3] = xm[i+1+n2*j];
-                   vertexx[4] = xm[i+n2*j];
-                 
-                   vertexy[0] = ym[j+n1*i];
-                   vertexy[1] = ym[j+1+n1*i];
-                   vertexy[2] = ym[j+1+n1*(i+1)];
-                   vertexy[3] = ym[j+n1*(i+1)];
-                   vertexy[4] = ym[j+n1*i];
-                   
-                   C2F(dr)("xliness","str",vertexx,vertexy,&fill,&un_,&cinq,
-                           PI0,PD0,PD0,PD0,PD0,0L,0L);
-                 }
-           
-             frame_clip_off();  
-#ifdef _MSC_VER
-             if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-           
-             FREE(xm); xm = (integer *) NULL;
-             FREE(ym); ym = (integer *) NULL;
-             FREE(xvect_); xvect_ = (double *) NULL;
-             FREE(yvect_); yvect_ = (double *) NULL;
-           }
-         }
-         break;
-       case 2: /* Matplot1 case */
-         /* In this case (and inside Matplot too but Matplot and Matplot1 are almost the same), */
-         /* dim x = n2 and dim y = n1 (cf. scimatplot in matdes.c) */ /* F.Leray 20.05.05 */
-         
-         if(pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d == FALSE){
-           if ((xm = MALLOC (n2*sizeof (integer))) == NULL) 
-             return -1;
-           if ((ym = MALLOC (n1*sizeof (integer))) == NULL){
-             FREE(xm);xm = (integer *) NULL; return -1; /* F.Leray Rajout de xm = (integer *) NULL; 18.02.04*/
-           }
-         
-           xx[0]=pGRAYPLOT_FEATURE (pobj)->pvecx[0];
-           xx[1]=pGRAYPLOT_FEATURE (pobj)->pvecx[2];
-           yy[0]=pGRAYPLOT_FEATURE (pobj)->pvecx[1];
-           yy[1]=pGRAYPLOT_FEATURE (pobj)->pvecx[3];
-           /** Boundaries of the frame **/
-           C2F(echelle2d)(xx,yy,px1,py1,&pn1,&pn2,"f2i",3L); 
-           for ( j =0 ; j < n2 ; j++)   
-             xm[j]= (int) (( px1[1]*j + px1[0]*((n2-1)-j) )/(n2-1));
-  
-           for ( j =0 ; j < n1 ; j++)   
-             ym[j]= (int) (( py1[0]*j + py1[1]*((n1-1)-j) )/ (n1-1)); 
-#ifdef _MSC_VER
-           flag_DO = MaybeSetWinhdc();
-#endif
-
-           frame_clip_on(); 
-           GraySquare1(xm,ym,pGRAYPLOT_FEATURE (pobj)->pvecz,n1,n2); 
-           frame_clip_off();
-#ifdef _MSC_VER
-           if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-           /*    FREE(xm);FREE(ym); */ /* SS 03/01/03 */
-           FREE(xm); xm = (integer *) NULL; /* F.Leray c'est mieux.*/
-           FREE(ym); ym = (integer *) NULL;
-         }
-         else{
-           /* 3D version */
-           double * xvect_ = NULL;
-           double * yvect_ = NULL;
-          
-           /* Warning here (Matplot case) : n1 becomes n2 and vice versa */
-           if ((xvect_ = MALLOC (n2*sizeof (double))) == NULL) return -1;
-           if ((yvect_ = MALLOC (n1*sizeof (double))) == NULL){
-             FREE(xvect_); xvect_ = (double *) NULL; return -1;
-           }
-          
-           xx[0]=pGRAYPLOT_FEATURE (pobj)->pvecx[0];
-           xx[1]=pGRAYPLOT_FEATURE (pobj)->pvecx[2];
-           yy[0]=pGRAYPLOT_FEATURE (pobj)->pvecx[1];
-           yy[1]=pGRAYPLOT_FEATURE (pobj)->pvecx[3];
-          
-          
-           /** Boundaries of the frame **/
-           for ( i =0 ; i < n2 ; i++)
-             xvect_[i]= (( xx[1]*i + xx[0]*((n2-1)-i) )/(n2-1));
-          
-           for ( j =0 ; j < n1 ; j++)
-             yvect_[j]= (( yy[0]*j + yy[1]*((n1-1)-j) )/ (n1-1)); 
-          
-          
-           if ((xm = MALLOC (n2*n1*sizeof (integer))) == NULL) return -1;
-           if ((ym = MALLOC (n1*n2*sizeof (integer))) == NULL){
-             FREE(xm); xm = (integer *) NULL; return -1; 
-           }
-          
-           ReverseDataFor3DXonly(sciGetParentSubwin(pobj),xvect_,n2);
-           ReverseDataFor3DYonly(sciGetParentSubwin(pobj),yvect_,n1);
-          
-          
-           for ( i =0 ; i < n2 ; i++)  /* on x*/
-             for ( j =0 ; j < n1 ; j++)  /* on y */
-               trans3d(sciGetParentSubwin(pobj),1,&xm[i+j*n2],&ym[j+i*n1],
-                       &xvect_[i],&yvect_[j],NULL);
-          
-#ifdef _MSC_VER
-           flag_DO = MaybeSetWinhdc();
-#endif
-           frame_clip_on(); 
-          
-           /* draw the filled projected rectangle */
-           for (i = 0 ; i < (n2)-1 ; i++){
-             for (j = 0 ; j < (n1)-1 ; j++)
-               {
-                 integer vertexx[5], vertexy[5];
-                 int cinq = 5, un_ = 1;
-                 integer fill;
-
-                 fill = (int) - pGRAYPLOT_FEATURE (pobj)->pvecz[(n1-1)*i+j];
-                
-                 vertexx[0] = xm[i+n2*j];
-                 vertexx[1] = xm[i+n2*(j+1)];
-                 vertexx[2] = xm[i+1+n2*(j+1)];
-                 vertexx[3] = xm[i+1+n2*j];
-                 vertexx[4] = xm[i+n2*j];
-                
-                 vertexy[0] = ym[j+n1*i];
-                 vertexy[1] = ym[j+1+n1*i];
-                 vertexy[2] = ym[j+1+n1*(i+1)];
-                 vertexy[3] = ym[j+n1*(i+1)];
-                 vertexy[4] = ym[j+n1*i];
-                 
-                 C2F(dr)("xliness","str",vertexx,vertexy,&fill,&un_,&cinq,
-                         PI0,PD0,PD0,PD0,PD0,0L,0L);
-               }
-        }
-          
-           frame_clip_off();  
-#ifdef _MSC_VER
-           if ( flag_DO == 1) ReleaseWinHdc();
-#endif
-           FREE(xm); xm = (integer *) NULL;
-           FREE(ym); ym = (integer *) NULL;
-           FREE(xvect_); xvect_ = (double *) NULL;
-           FREE(yvect_); yvect_ = (double *) NULL;
-         }
-         break;
-       default:
-         break;
-       }
-      break;
-    case SCI_POLYLINE:
-      if (!sciGetVisibility(pobj)) break;
-     
-      /*sciSetCurrentObj (pobj);         F.Leray 25.03.04 */
-     
-      itmp[0] = 0;             /* verbose*/
-      itmp[1] = 0;             /* thickness value*/
-      itmp[2] = 1;             /* narg*/
-     
-      /* load the object foreground and dashes color */
-      x[0] = sciGetForeground (pobj);  
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = sciGetLineStyle (pobj);
-  
-      x[4] = 0;
-      v = 0;
-      dv = 0;
-      logflags[0]='g';
-      logflags[1]= pSUBWIN_FEATURE(sciGetParentSubwin(pobj))->logflags[0]; /* F.Leray 26.10.04 Pb when logscale on and data is <= 0 for clipping */
-      logflags[2]= pSUBWIN_FEATURE(sciGetParentSubwin(pobj))->logflags[1];
-      logflags[3]='\0';
-     
-
-      x_shift = pPOLYLINE_FEATURE (pobj)->x_shift;
-      y_shift = pPOLYLINE_FEATURE (pobj)->y_shift;
-      z_shift = pPOLYLINE_FEATURE (pobj)->z_shift;
-    
-
-      /* //////////////////////////////////////////////////////////////// */
-      BuildXYZvectForClipping_IfNanOrLogON(pobj,sciGetParentSubwin(pobj),&nb_curves, &xvect, &yvect, &zvect, &curves_size);
-      /* //////////////////////////////////////////////////////////////// */
-      
-#ifdef _MSC_VER 
-      flag_DO = MaybeSetWinhdc();
-#endif
-      
-      C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-               &dv, &dv, &dv, 5L, 4096);
-      C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-               &dv, &dv, &dv, &dv, 5L, 4096);
-      C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);
-      C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);
-   
-#ifdef _MSC_VER 
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif  
-      n1 = pPOLYLINE_FEATURE (pobj)->n1;
-      /* n2 = 1; */ /* the number of curves is always 1 since we draw each one line at a given time */
-      nb_curves_bar = pPOLYLINE_FEATURE (pobj)->n2;
-      closeflag = pPOLYLINE_FEATURE (pobj)->closed; /* 0 or 1 */
-      
-      /***/
-      sciClip(pobj);
-
-
-#ifdef _MSC_VER 
-      flag_DO = MaybeSetWinhdc ();
-#endif
-
-
-      for(jk=0;jk<nb_curves;jk++)
-       {
-         n1 = curves_size[jk];
-
-         if(n1==0) continue;
-         
-         if ((xm = MALLOC ((2*n1)*sizeof (integer))) == NULL)  return -1;
-         if ((ym = MALLOC ((2*n1)*sizeof (integer))) == NULL)  return -1;
-         if ((xzz = MALLOC ((2*n1)*sizeof (double))) == NULL)  return -1;
-         if ((yzz = MALLOC ((2*n1)*sizeof (double))) == NULL)  return -1;
-         if ((zzz = MALLOC ((2*n1)*sizeof (double))) == NULL)  return -1;
-         
-         /**DJ.Abdemouche 2003**/
-         switch (pPOLYLINE_FEATURE (pobj)->plot)
-           {
-           case 1:  /* case plot2d, xpoly */
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d){
-               drawline = TRUE;
-               /* axes reverse is tested and xvect, yvect are changed if needed here */
-               ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-               
-               result_trans3d = trans3d(sciGetParentSubwin(pobj),n1,xm,ym,xvect[jk],yvect[jk],zvect[jk]);
-             }
-             else{
-               drawline = TRUE;
-               /* In 2d, the axes reverse is done inside XScale, YScale... routines. */
-               C2F (echelle2d) (xvect[jk],yvect[jk], xm, ym, &n1, &un, "f2i",3L); 
-             }
-             break; 
-           case 2:
-             drawline = TRUE;
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-               {
-                 if(zvect[jk] == NULL){
-                   FREE(zzz); zzz = (double *) NULL;
-                 }
-                 
-                 ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-                 
-                 Plo2dTo3d(2,&un,&n1,xvect[jk],yvect[jk],zvect[jk],xzz,yzz,zzz);
-                 result_trans3d = trans3d(sciGetParentSubwin(pobj),n1*2,xm,ym,xzz,yzz,zzz);
-               }
-             else
-               {
-                 Plo2d2RealToPixel(&un,&n1,xvect[jk],yvect[jk],xm,ym,logflags);
-               }
-             n1=n1*2;
-             break;
-           case 3:  
-             drawline = FALSE;
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-               {
-                 if(zvect[jk] == NULL){
-                   FREE(zzz); zzz = (double *) NULL;
-                 }
-                   
-                 ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-                 
-                 Plo2dTo3d(3,&un,&n1,xvect[jk],yvect[jk],zvect[jk],xzz,yzz,zzz);
-                 result_trans3d = trans3d(sciGetParentSubwin(pobj),n1*2,xm,ym,xzz,yzz,zzz);
-               }
-             else
-               {
-                 Plo2d3RealToPixel(&un,&n1,xvect[jk],yvect[jk],xm,ym,logflags);
-               }
-             if(result_trans3d == 1)
-               nn1= n1*2;
-             /* add mark support even for bar plot lines */
-             if (sciGetIsMark(pobj) == TRUE){
-               int x_[4], markidsizenew_[2];
-               x[0] = sciGetMarkForeground(pobj);
-               
-               markidsizenew_[0] = sciGetMarkStyle(pobj);
-               markidsizenew_[1] = sciGetMarkSize (pobj);
-               
-               C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                         &dv, &dv, &dv, 5L, 4096);
-               C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                         &dv, &dv, &dv, &dv, 5L, 4096);
-               
-               C2F (dr) ("xset", "mark", &markidsizenew_[0], &markidsizenew_[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                         PD0, PD0, 0L, 0L);   
-               
-               DrawNewMarks(pobj,nn1,&xm[0],&ym[0],DPI);
-             }
-             
-             if (sciGetIsLine(pobj) == TRUE){
-               lstyle=sciGetForeground(pobj);
-               iflag=0; 
-               C2F(dr)("xsegs","v",&xm[0],&ym[0],&nn1,&lstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
-             }
-             /**DJ.Abdemouche 2003**/
-             n1=un;
-             break;
-           case 4:
-             drawline = FALSE;
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-               {
-                 if(zvect[jk] == NULL){
-                   FREE(zzz); zzz = (double *) NULL;
-                 }
-                 
-                 ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-                 
-                 Plo2dTo3d(4,&un,&n1,xvect[jk],yvect[jk],zvect[jk],xzz,yzz,zzz);
-                 
-                 result_trans3d = trans3d(sciGetParentSubwin(pobj),n1*2,xm,ym,xzz,yzz,zzz);
-               }
-             else
-               {
-                 Plo2d4RealToPixel(&un,&n1,xvect[jk],yvect[jk],xm,ym,logflags); 
-               }
-             nn2=2*(n1)-1;
-             arsize1= Cscale.WIRect1[2]/70.0;arsize2= Cscale.WIRect1[3]/70.0;
-             arsize=  (arsize1 < arsize2) ? inint(10*arsize1) : inint(10*arsize2) ;
-             
-             if(result_trans3d == 1){
-               integer lstyle_=sciGetForeground(pobj) ,iflag_=0;
-               
-               /* add mark support even for arrow line style */
-               if (sciGetIsMark(pobj) == TRUE){
-                 int x_[4], markidsizenew_[2];
-                 x_[0] = sciGetMarkForeground(pobj);
-                 
-                 markidsizenew_[0] = sciGetMarkStyle(pobj);
-                 markidsizenew_[1] = sciGetMarkSize (pobj);
-                 
-                 C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                           &dv, &dv, &dv, 5L, 4096);
-                 C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                           &dv, &dv, &dv, &dv, 5L, 4096);
-                 
-                 C2F (dr) ("xset", "mark", &markidsizenew_[0], &markidsizenew_[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                           PD0, PD0, 0L, 0L);   
-                 
-                 DrawNewMarks(pobj,nn2,&xm[0],&ym[0],DPI);
-               }
-               
-               if (sciGetIsLine(pobj) == TRUE){
-                 x[0] = sciGetForeground(pobj);
-                 x[2] = sciGetLineWidth (pobj);
-                 x[3] = sciGetLineStyle (pobj);
-                 
-                 C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-                           &dv, &dv, &dv, 5L, 4096);
-                 C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                 C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-                           PD0, PD0, PD0, 0L, 0L);
-                 C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-                           PD0, PD0, PD0, 0L, 0L);
-                 
-                 arsize = (integer) pPOLYLINE_FEATURE(pobj)->arsize_factor * arsize;
-
-                 C2F(dr)("xarrow","v",&xm[0],&ym[0],&nn2,&arsize,&lstyle_,&iflag_,PD0,PD0,PD0,PD0,0L,0L);
-               }
-             }
-             break;
-           case 5: /* case xfpoly */
-             drawline = TRUE;
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d){
-               ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-               result_trans3d = trans3d(sciGetParentSubwin(pobj),n1,xm,ym,xvect[jk],yvect[jk],zvect[jk]);
-             }
-             else
-               C2F (echelle2d) (xvect[jk],yvect[jk], xm, ym, &n1, &un, "f2i",3L);
-             
-             sciClip(pobj);
-             
-             if(result_trans3d == 1)
-               C2F (dr) ("xarea", str, &n1, xm, ym, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-             
-             break;
-           case 6: /* 'Matlab' bar */
-             drawline = TRUE;
-             x[2] = sciGetLineWidth (pobj);
-             x[3] = sciGetLineStyle (pobj);
-             /* get the number of polylines sisters with bar property "on" */
-             
-             bar_width =  pPOLYLINE_FEATURE(pobj)->bar_width;
-             
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-               {
-                 double myX[4], myY[4], myZ[4];
-                 int pix_X[4], pix_Y[4];
-                 int quatre = 4;
-                 
-                 for(i=0;i<n1;i++)
-                   {
-                     myX[0] = myX[1] = xvect[jk][i] - bar_width/2;
-                     myX[2] = myX[3] = xvect[jk][i] + bar_width/2;
-                     if(y_shift == (double *) NULL)
-                       myY[0] = myY[3] =  0.;
-                     else
-                       myY[0] = myY[3] =  y_shift[i];
-                     myY[1] = myY[2] =  yvect[jk][i];
-                     
-                     if(zvect[jk] == (double *) NULL)
-                       myZ[0] = myZ[1] = myZ[2] = myZ[3] = 0.; /* cas log a revoir */
-                     else                    
-                       myZ[0] = myZ[1] = myZ[2] = myZ[3] = zvect[jk][i];
-                     
-                     ReverseDataFor3D(sciGetParentSubwin(pobj),myX,myY,myZ,quatre);
-                     result_trans3d = trans3d(sciGetParentSubwin(pobj),quatre,pix_X,pix_Y,myX,myY,myZ);
-                     
-                     x[0] = sciGetBackground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xarea", str, &quatre, pix_X, pix_Y, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-                     
-                     x[0] = sciGetForeground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                      
-                     /* encapsulate this for a clip check on each segment */
-                     C2F (dr) ("xlines", "xv", &quatre, pix_X, pix_Y, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-                   }
-
-                 ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-                 result_trans3d = trans3d(sciGetParentSubwin(pobj),n1,xm,ym,xvect[jk],yvect[jk],zvect[jk]);
-               }
-             else
-               {
-                 double myX[4], myY[4];
-                 int pix_X[4], pix_Y[4],i2;
-                 int quatre = 4;
-                 
-                 for(i2=0;i2<n1;i2++)
-                   {
-                     myX[0] = myX[1] = xvect[jk][i2] - bar_width/2;
-                     myX[2] = myX[3] = xvect[jk][i2] + bar_width/2;
-                     
-                     if(y_shift == (double *) NULL)
-                       myY[0] = myY[3] =  0.;
-                     else
-                       myY[0] = myY[3] =  y_shift[i2];
-                     myY[1] = myY[2] =  yvect[jk][i2];
-                     
-                     C2F (echelle2d) (myX,myY, pix_X, pix_Y, &quatre, &un, "f2i",3L);
-                     
-                     x[0] = sciGetBackground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xarea", str, &quatre, pix_X, pix_Y, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-                     
-                     x[0] = sciGetForeground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xlines", "xv", &quatre, pix_X, pix_Y, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-                   }
-                 C2F (echelle2d) (xvect[jk],yvect[jk], xm, ym, &n1, &un, "f2i",3L); 
-               }
-             break;
-           case 7: /* 'Matlab' barh */
-             drawline = TRUE;
-             x[2] = sciGetLineWidth (pobj);
-             x[3] = sciGetLineStyle (pobj);
-             /* get the number of polylines sisters with bar property "on" */
-             
-             bar_width =  pPOLYLINE_FEATURE(pobj)->bar_width;
-             
-             for(i=0;i<n1;i++)
-               {
-                 tempvect=xvect[jk][i];
-                 xvect[jk][i]=yvect[jk][i];
-                 yvect[jk][i]=tempvect;
-               }
-
-             if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-               {
-                 double myX[4], myY[4], myZ[4];
-                 int pix_X[4], pix_Y[4];
-                 int quatre = 4;
-                 
-                 for(i=0;i<n1;i++)
-                   {
-                     myY[0] = myY[1] = yvect[jk][i] + bar_width/2;
-                     myY[2] = myY[3] = yvect[jk][i] - bar_width/2;
-                     
-                     if(y_shift == (double *) NULL)
-                       myX[0] = myX[3] =  0.;
-                     else 
-                       myX[0] = myX[3] =  y_shift[i];
-                     myX[1] = myX[2] =  xvect[jk][i];
-                     
-                     if(zvect[jk] == (double *) NULL)
-                       myZ[0] = myZ[1] = myZ[2] = myZ[3] = 0.; /* cas log a revoir */
-                     else                    
-                       myZ[0] = myZ[1] = myZ[2] = myZ[3] = zvect[jk][i];
-                     
-                     ReverseDataFor3D(sciGetParentSubwin(pobj),myX,myY,myZ,quatre);
-                     result_trans3d = trans3d(sciGetParentSubwin(pobj),quatre,pix_X,pix_Y,myX,myY,myZ);
-                     
-                     x[0] = sciGetBackground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xarea", str, &quatre, pix_X, pix_Y, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-                     
-                     x[0] = sciGetForeground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xlines", "xv", &quatre, pix_X, pix_Y, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-                   }
-
-                 ReverseDataFor3D(sciGetParentSubwin(pobj),xvect[jk],yvect[jk],zvect[jk],n1);
-                 result_trans3d = trans3d(sciGetParentSubwin(pobj),n1,xm,ym,xvect[jk],yvect[jk],zvect[jk]);
-               }
-             else
-               {
-                 double myX[4], myY[4];
-                 int pix_X[4], pix_Y[4],i2;
-                 int quatre = 4;
-                 
-                 for(i2=0;i2<n1;i2++)
-                   {
-                     myY[0] = myY[1] = yvect[jk][i2] + bar_width/2;
-                     myY[2] = myY[3] = yvect[jk][i2] - bar_width/2;
-                     
-                     if(y_shift == (double *) NULL)
-                       myX[0] = myX[3] =  0.;
-                     else 
-                       myX[0] = myX[3] =  y_shift[i2];
-                     myX[1] = myX[2] =  xvect[jk][i2];
-                     
-                     C2F (echelle2d) (myX,myY, pix_X, pix_Y, &quatre, &un, "f2i",3L);
-                     
-                     x[0] = sciGetBackground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xarea", str, &quatre, pix_X, pix_Y, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-                     
-                     x[0] = sciGetForeground(pobj);
-                     
-                     C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                               &dv, &dv, &dv, 5L, 4096);
-                     C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                               &dv, &dv, &dv, &dv, 5L, 4096);
-                     
-                     C2F (dr) ("xlines", "xv", &quatre, pix_X, pix_Y, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-                   }
-                 C2F (echelle2d) (xvect[jk],yvect[jk], xm, ym, &n1, &un, "f2i",3L); 
-               }
-             break;
-           default:
-             sciprint ("This Polyline cannot be drawn !\n");
-/* #ifdef _MSC_VER  */
-/*           if ( flag_DO == 1) ReleaseWinHdc (); */
-/* #endif   */
-             break;     
-           }
-        
-         if(result_trans3d == 1 && drawline == TRUE)
-           {
-             if(sciGetIsFilled(pobj) == TRUE && pPOLYLINE_FEATURE (pobj)->plot != 5) /* No filling if mode plot == 5 is selected */
-               {
-                 if(pPOLYLINE_FEATURE (pobj)->isinterpshaded == FALSE){
-                   /* flat mode */
-                   x[0] = sciGetBackground(pobj);
-                   
-                   C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                             &dv, &dv, &dv, 5L, 4096);
-                   C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                             &dv, &dv, &dv, &dv, 5L, 4096);
-                   
-                   C2F (dr) ("xarea", str, &n1, xm, ym, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-                 }
-                 else{
-                   /* interp. shading */
-                   int *vect = pPOLYLINE_FEATURE (pobj)->scvector;
-                   int nn = pPOLYLINE_FEATURE (pobj)->n1;
-
-                   scilab_shade (xm, ym, vect, nn, 0);
-                 }
-               }
-             
-             if ( sciGetIsMark(pobj) )
-              {
-               int x_[4], markidsizenew_[2];
-               x_[0] = sciGetMarkForeground(pobj);
-              
-               markidsizenew_[0] = sciGetMarkStyle(pobj);
-               markidsizenew_[1] = sciGetMarkSize (pobj);
-               
-               C2F (dr) ("xset", "dashes", x_, x_, x_+4, x_+4, x_+4, &v, &dv,
-                         &dv, &dv, &dv, 5L, 4096);
-               C2F (dr) ("xset", "foreground", x_, x_, x_+4, x_+4, x_+4, &v,
-                         &dv, &dv, &dv, &dv, 5L, 4096);
-              
-               C2F (dr) ("xset", "mark", &markidsizenew_[0], &markidsizenew_[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                         PD0, PD0, 0L, 0L);   
-               
-               DrawNewMarks(pobj,n1,xm,ym,DPI);
-             }
-             
-             if ( sciGetIsLine(pobj) )
-              {
-                
-               x[0] = sciGetForeground( pobj ) ;
-                x[2] = sciGetLineWidth(  pobj ) ;
-                x[3] = sciGetLineStyle( pobj ) ;
-               
-               C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                         &dv, &dv, &dv, 5L, 4096);
-               C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                         &dv, &dv, &dv, &dv, 5L, 4096);
-               C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-                         PD0, PD0, PD0, 0L, 0L);
-               C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-                         PD0, PD0, PD0, 0L, 0L);
-                
-                C2F (dr) ("xlines", "xv", &n1, xm, ym, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-                
-             }
-           }
-         
-#ifdef _MSC_VER
-         if ( flag_DO == 1) ReleaseWinHdc ();
-#endif
-        
-         FREE(xzz); xzz = (double *) NULL;
-         FREE(yzz); yzz = (double *) NULL;
-         FREE(zzz); zzz = (double *) NULL;/* SS 02/04 */
-         
-         FREE (xm); xm = (integer *) NULL;
-         FREE (ym); ym = (integer *) NULL;
-         
-       }
-      
-
-      for(i=0;i<nb_curves;i++){
-       int nn;
-       nn = curves_size[i];
-       
-       if(nn==0) continue;
-       
-       FREE(xvect[i]); xvect[i] = (double *) NULL;
-       FREE(yvect[i]); yvect[i] = (double *) NULL;
-       FREE(zvect[i]); zvect[i] = (double *) NULL;
-      }
-      FREE(xvect); xvect = (double **) NULL;
-      FREE(yvect); yvect = (double **) NULL;
-      /*   if(zvect != (double **) NULL) */
-      FREE(zvect); zvect = (double **) NULL;
-      
-      FREE(curves_size); curves_size = NULL;
-
-#ifdef _MSC_VER 
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif  
-      
-      sciUnClip(pobj);
-      
-      
-      break;
-    case SCI_ARC:
-      if (!sciGetVisibility(pobj)) break;
-      /*sciSetCurrentObj (pobj);       F.Leray 25.03.04 */
-      n = 1;
-      
-     
-      itmp[0] = 0;             /* verbose*/
-      itmp[1] = 0;             /* thickness value*/
-      itmp[2] = 1;             /* narg*/
-      C2F (dr) ("xget", "thickness", itmp, itmp+1, itmp+2, PI0, PI0,
-               PI0, PD0, PD0, PD0, PD0, 4L, 9L);
-
-      /* load the object foreground and dashes color */
-
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = sciGetLineStyle (pobj);
-      x[4] = 0;
-      v = 0;
-      dv = 0;
-#ifdef _MSC_VER 
-      flag_DO = MaybeSetWinhdc ();
-#endif
-    
-      C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, 
-               PD0, PD0, PD0, PD0, 4L, 9L);   
-      C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, 
-               PD0, PD0, PD0, PD0, 4L, 10L);
-      
-#ifdef _MSC_VER 
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif
-      /**DJ.Abdemouche 2003**/
-      if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d)
-       {
-         
-         double xvect_;
-         double yvect_;
-         double zvect_;
-         
-         xvect_ = pARC_FEATURE(pobj)->x;
-         yvect_ = pARC_FEATURE(pobj)->y;
-         zvect_ = pARC_FEATURE(pobj)->z;
-         
-         ReverseDataFor3D(sciGetParentSubwin(pobj),&xvect_,&yvect_,&zvect_,un);
-         
-         trans3d(sciGetParentSubwin(pobj),un,&x1,&yy1,&xvect_,&yvect_,&zvect_);
-       }
-      else
-       {
-         sciSubWindow * ppsubwin2 = pSUBWIN_FEATURE (sciGetParentSubwin(pobj));
-         double tmpx = pARC_FEATURE (pobj)->x;
-         double tmpy = pARC_FEATURE (pobj)->y;
-         
-         double tmpwidth = pARC_FEATURE (pobj)->width;
-         double tmpheight= pARC_FEATURE (pobj)->height;
-         
-         if(ppsubwin2->axes.reverse[0] == TRUE){
-           tmpx= tmpx + tmpwidth;
-         }
-         
-         if(ppsubwin2->axes.reverse[1] == TRUE){
-           tmpy = tmpy - tmpheight;
-         }
-         
-         x1  = XDouble2Pixel (tmpx);
-         yy1 = YDouble2Pixel (tmpy);
-       }
-
-      w2 = pARC_FEATURE (pobj)->width;
-      h2 = pARC_FEATURE (pobj)->height; 
-      /* Nouvelles fonctions de changement d'echelle pour les longueurs --> voir PloEch.h */ 
-      
-      w1 = WScale(w2);
-      h1 = HScale(h2);
-      
-      angle1 = (integer) (pARC_FEATURE (pobj)->alphabegin);
-      angle2 = (integer) (pARC_FEATURE (pobj)->alphaend); 
-
-      if((pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->axes.reverse[0] == TRUE)
-        && (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->axes.reverse[1] == FALSE)){
-       angle1 = 180*64 - (angle2+angle1);
-      }
-      else if((pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->axes.reverse[0] == TRUE)
-             && (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->axes.reverse[1] == TRUE)){
-       angle1 = 180*64 + angle1;
-      }
-      else if((pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->axes.reverse[0] == FALSE)
-             && (pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->axes.reverse[1] == TRUE)){
-       angle1 = 360*64 - (angle2+angle1);
-      }
-     
-#ifdef _MSC_VER 
-      flag_DO = MaybeSetWinhdc ();
-#endif
-      sciClip(pobj);
-      
-      if(sciGetIsFilled(pobj) == TRUE){
-       x[0] = sciGetBackground(pobj);
-       C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, 
-                 &dv, &dv, &dv, &dv, 5L, 6L);
-       C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4,&v, 
-                 &dv, &dv, &dv, &dv, 5L, 10L );
-       C2F (dr) ("xfarc", str, &x1, &yy1, &w1, &h1, &angle1, &angle2, PD0, PD0, PD0,PD0, 0L, 0L);
-      }
-      
-      if(sciGetIsLine(pobj) == TRUE){
-       x[0] = sciGetForeground(pobj);
-       C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, 
-                 &dv, &dv, &dv, &dv, 5L, 6L);
-       C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4,&v, 
-                 &dv, &dv, &dv, &dv, 5L, 10L );
-       C2F (dr) ("xarc", str, &x1, &yy1, &w1, &h1, &angle1, &angle2, PD0, PD0, PD0,PD0, 5L, 0L);
-      }
-      
-/*       if (pARC_FEATURE (pobj)->fill  <= 0) */
-/*     C2F (dr) ("xarc", str, &x1, &yy1, &w1, &h1, &angle1, &angle2, PD0, PD0, PD0,PD0, 5L, 0L); */
-/*       else */
-/*     C2F (dr) ("xfarc", str, &x1, &yy1, &w1, &h1, &angle1, &angle2, PD0, PD0, PD0,PD0, 5L, 0L); */
-      sciUnClip(pobj);
-#ifdef _MSC_VER 
-      if ( flag_DO == 1)  ReleaseWinHdc ();
-#endif
-      break;
-    case SCI_RECTANGLE:
-    {
-      sciRectangle * ppRect = pRECTANGLE_FEATURE (pobj) ;
-      /* store the size of the rectangle */
-      double ulPoint[3]  = { ppRect->x, ppRect->y, ppRect->z } ;
-      double rectSize[2] = { ppRect->width, ppRect->height }   ;
-      int rectEdgesX[4] ;
-      int rectEdgesY[4] ;
-      if (!sciGetVisibility(pobj)) break;
-      n = 1;
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = sciGetLineStyle (pobj);
-      x[4] = 0;
-
-      v = 0;
-      dv = 0; 
-#ifdef _MSC_VER 
-      flag_DO = MaybeSetWinhdc ();
-#endif
-
-      C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);    
-      C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);
-
-#ifdef _MSC_VER 
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif 
-
-      /* get the 4 vertices of the rectangle in pixels */
-      rectangleDouble2Pixel( sciGetParentSubwin(pobj),
-                             ulPoint                 ,
-                             rectSize                ,
-                             rectEdgesX              ,
-                             rectEdgesY                ) ;
-
-      /**DJ.Abdemouche 2003**/
-      if ( !(pSUBWIN_FEATURE (sciGetParentSubwin(pobj))->is3d) )
-      {
-        int rectPixPosX   ;
-        int rectPixPosY   ;
-        int rectPixWidth  ;
-        int rectPixHeight ;
-        
-        /* retrieve x,y,w,h */
-        rectPixPosX   = rectEdgesX[0] ;
-        rectPixPosY   = rectEdgesY[0] ;
-        rectPixWidth  = rectEdgesX[2] - rectEdgesX[0] ;
-        rectPixHeight = rectEdgesY[2] - rectEdgesY[0] ;
-
-        if ( ppRect->strwidth == 0 )
-        {
-          ppRect->strwidth  = rectPixWidth  ;
-          ppRect->strheight = rectPixHeight ;
-          
-        }
-        wstr=ppRect->strwidth;
-        hstr=ppRect->strheight;
-         
-         
-#ifdef _MSC_VER 
-        flag_DO = MaybeSetWinhdc ();
-#endif
-        sciClip(pobj);
-
-        if( sciGetIsFilled(pobj) )
-        {
-          x[0] = sciGetBackground(pobj);
-          C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, 
-                    &dv, &dv, &dv, &dv, 5L, 6L);
-          C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4,&v, 
-                    &dv, &dv, &dv, &dv, 5L, 10L );
-          C2F(dr)("xfrect",str,&rectPixPosX,&rectPixPosY,&rectPixWidth,&rectPixHeight,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-        }
-         
-        if( sciGetIsMark(pobj) )
+        if ( pPOLYLINE_FEATURE(psonstmp->pointobj)->n1 == 0 )
         {
-          x[0] = sciGetMarkForeground(pobj);
-              
-          markidsizenew[0] =  sciGetMarkStyle(pobj);
-          markidsizenew[1] =  sciGetMarkSize(pobj);
-             
-          C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                    &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                    &dv, &dv, &dv, &dv, 5L, 4096);
-            
-          C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                    PD0, PD0, 0L, 0L);
-            
-          n = 4;
-          xtmp[0] = rectPixPosX ;
-          xtmp[1] = rectPixPosX + rectPixWidth ;
-          xtmp[2] = rectPixPosX + rectPixWidth ;
-          xtmp[3] = rectPixPosX ;
-          ytmp[0] = rectPixPosY ;
-          ytmp[1] = rectPixPosY ;
-          ytmp[2] = rectPixPosY + rectPixHeight ;
-          ytmp[3] = rectPixPosY + rectPixHeight ;
-            
-          DrawNewMarks(pobj,n,xtmp,ytmp,DPI);
+          N = 0 ;
         }
-
-        if (sciGetIsLine(pobj))
-        {
-          x[0] = sciGetForeground(pobj);
-
-          C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-                    &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "foreground", x, x, x+3, x+3, x+3, &v,
-                    &dv, &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-                    PD0, PD0, PD0, 0L, 0L);    
-          C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-                    PD0, PD0, PD0, 0L, 0L);
-             
-
-          if (ppRect->str == 1)
-          {
-            rectPixPosY -= hstr;
-            C2F(dr)("xrect",str,&rectPixPosX,&rectPixPosY,&wstr,&hstr,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-          }
-          else
+        else if (pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 5)
+        {/*polyline*/
+          N = pPOLYLINE_FEATURE (psonstmp->pointobj)->n1-1;
+          if ((pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 2) && 
+            (sciGetIsMark((sciPointObj *)psonstmp->pointobj) == 1))
           {
-            C2F(dr)("xrect",str,&rectPixPosX,&rectPixPosY,&rectPixWidth,&rectPixHeight,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+            N = N + 1 ;
           }
         }
-         
-        sciUnClip(pobj);
-#ifdef _MSC_VER
-        if ( flag_DO == 1)  ReleaseWinHdc ();
-#endif
-      }
-      else /* Rect. in 3D */
-      { 
-        int close=1;
-        n=4;
-                
-#ifdef _MSC_VER
-        flag_DO = MaybeSetWinhdc ();
-#endif
-        sciClip(pobj);
-
-         
-        if( sciGetIsFilled(pobj) )
-        {
-          x[0] = sciGetBackground(pobj);
-          C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, 
-                    &dv, &dv, &dv, &dv, 5L, 6L);
-          C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4,&v, 
-                    &dv, &dv, &dv, &dv, 5L, 10L );
-          C2F (dr) ("xarea", str, &n, rectEdgesX, rectEdgesY, &close, PI0, PI0, PD0, PD0, PD0, PD0, 5L,strlen(str));
-        }
-         
-        if (sciGetIsMark(pobj)) 
-        {
-          x[0] = sciGetMarkForeground(pobj);
-                
-          markidsizenew[0] =  sciGetMarkStyle(pobj);
-          markidsizenew[1] =  sciGetMarkSize(pobj);
-
-          C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-                    &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-                    &dv, &dv, &dv, &dv, 5L, 4096);
-            
-          C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-                    PD0, PD0, 0L, 0L);
-            
-          n=4;
-            
-          DrawNewMarks(pobj,n,rectEdgesX,rectEdgesY,DPI);
-        }
-
-        if (sciGetIsLine(pobj)) 
+        else /* patch */
         {
-          x[0] = sciGetForeground(pobj);
-          C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-                    &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "foreground", x, x, x+3, x+3, x+3, &v,
-                    &dv, &dv, &dv, &dv, 5L, 4096);
-          C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-                    PD0, PD0, PD0, 0L, 0L);    
-          C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0,
-                    PD0, PD0, PD0, 0L, 0L);
-             
-          C2F (dr) ("xlines", "xv", &n, rectEdgesX, rectEdgesY, &close, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
+          N = 1 ;
         }
-
-        sciUnClip(pobj);
-#ifdef _MSC_VER 
-        if ( flag_DO == 1)  ReleaseWinHdc ();
-#endif
-      }
-    }
-    break;
-    case SCI_TEXT:
-      drawText( pobj ) ;
-      break;
-      
-    case SCI_AXES:
-      if (!sciGetVisibility(pobj)) break;
-      /*sciSetCurrentObj (pobj);       F.Leray 25.03.04 */
-      
-      /* load the object foreground and dashes color */
-      
-      x[0] = sciGetForeground (pobj);
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = 0;
-      x[4] = 0;
-      v = 0;
-      dv = 0;
-#ifdef _MSC_VER 
-      flag_DO = MaybeSetWinhdc ();
-#endif
-      C2F (dr) ("xset", "dashes", x, x, x+3, x+3, x+3, &v, &dv,
-               &dv, &dv, &dv, 5L, 4096);
-      C2F (dr) ("xset", "foreground", x, x, x+3, x+3, x+3, &v,
-               &dv, &dv, &dv, &dv, 5L, 4096);
-      C2F (dr) ("xset", "thickness", x+2, PI0, PI0, PI0, PI0, PI0, PD0,
-               PD0, PD0, PD0, 0L, 0L);
-      sciClip(pobj);
-     
-      /* Prototype Sci_Axis HAS CHANGED:  ************* F.Leray 19.05.04
-        void Sci_Axis(pos,xy_type,x,nx,y,ny,str,subtics,format,fontsize,textcolor,fontstyle,ticscolor,logflag,seg_flag, axisbuild_flag)
-        For the moment, for a simple axes ( coming from a scilab command as 'drawaxis'), we set the fontstyle to 0.
-      */
-
-      /* variable tmpAxes init. for debugging: */
-      paxes = pAXES_FEATURE(pobj);
-
-
-      Sci_Axis(pAXES_FEATURE(pobj)->dir,pAXES_FEATURE (pobj)->tics,pAXES_FEATURE(pobj)->vx,
-              &pAXES_FEATURE (pobj)->nx,pAXES_FEATURE(pobj)->vy,&pAXES_FEATURE (pobj)->ny,
-              pAXES_FEATURE(pobj)->str,pAXES_FEATURE (pobj)->subint,pAXES_FEATURE (pobj)->format,
-              pAXES_FEATURE (pobj)->fontsize,pAXES_FEATURE (pobj)->textcolor,fontstyle_zero, /* F.Leray 08.04.04 : Adding here fontstyle_zero*/
-              pAXES_FEATURE (pobj)->ticscolor,(char)(pAXES_FEATURE (pobj)->logscale),pAXES_FEATURE (pobj)->seg, 1); 
-#ifdef _MSC_VER 
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif
-      sciUnClip(pobj);   
-                         
-      break;
-    case SCI_MERGE:
-      if (!(pSUBWIN_FEATURE (sciGetParentSubwin(pobj) )->facetmerge)) break; 
-     
-      /*     if (!sciGetVisibility(pobj)) break; */
-     
-      DrawMerge3d(sciGetParentSubwin(pobj), pobj, DPI);  /* TEST on sciGetVisibility inside */
-      break;
-    case SCI_SURFACE:
-     
-      ppsurface = pSURFACE_FEATURE (pobj);
-
-      if (pSUBWIN_FEATURE (sciGetParentSubwin(pobj) )->facetmerge) break;  
-      if (!sciGetVisibility(pobj)) break;
-      itmp[0] = 0;             /* verbose*/
-      itmp[1] = 0;             /* thickness value*/
-      itmp[2] = 1;             /* narg*/
-      C2F (dr) ("xget", "thickness", &itmp[0], &itmp[1], &itmp[2], PI0, PI0,PI0, PD0, PD0, PD0, PD0, 4L, 9L);
-      C2F (dr) ("xget", "mark", &itmp[0], markidsizeold, &itmp[3], PI0, PI0, PI0,PD0, PD0, PD0, PD0, 4L, 4L);
-
-      /* load the object foreground and dashes color */
-/*       x[0] = sciGetForeground (pobj);        */
-      x[2] = sciGetLineWidth (pobj);
-      x[3] = sciGetLineStyle (pobj);
-      markidsizenew[0] = sciGetMarkStyle(pobj);
-      markidsizenew[1] = sciGetLineWidth (pobj);
-      x[4] = 0;v = 0;dv = 0; 
-#ifdef _MSC_VER
-      flag_DO = MaybeSetWinhdc();
-#endif
-      C2F (dr) ("xset", "thickness",  x+2, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 5L, 9L);
-      C2F (dr) ("xset", "line style", x+3, PI0, PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 0L, 0L); /*D.A 17/12/2003*/
-      C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0, PD0, PD0, 4L, 4L);
-#ifdef _MSC_VER
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif
-      
-      
-      n=1;               
-#ifdef _MSC_VER
-      flag_DO = MaybeSetWinhdc();
-#endif
-      switch(pSURFACE_FEATURE (pobj)->typeof3d)
-       {
-       case SCI_FAC3D:
-         C2F(fac3dn)(pobj,pSURFACE_FEATURE (pobj)->pvecx,pSURFACE_FEATURE (pobj)->pvecy,
-                     pSURFACE_FEATURE (pobj)->pvecz,
-                     pSURFACE_FEATURE (pobj)->color,
-                     &pSURFACE_FEATURE (pobj)->dimzx,&pSURFACE_FEATURE (pobj)->dimzy, DPI);
-
-         break;
-       case SCI_PLOT3D:
-         C2F(plot3dn)(pobj,pSURFACE_FEATURE (pobj)->pvecx,pSURFACE_FEATURE (pobj)->pvecy,
-                      pSURFACE_FEATURE (pobj)->pvecz,
-                      &pSURFACE_FEATURE (pobj)->dimzx,&pSURFACE_FEATURE (pobj)->dimzy, DPI);
-         break;
-       default:
-         break;
-       }
-#ifdef _MSC_VER
-      if ( flag_DO == 1) ReleaseWinHdc ();
-#endif
-      break;
-    case SCI_LIGHT:
-    case SCI_PANNER:
-    case SCI_SBH:
-    case SCI_SBV:
-    case SCI_MENU:
-    case SCI_MENUCONTEXT:
-    case SCI_STATUSB:
-    default:
-      return -1;
-      break;
-    }
-  sciSetSelectedSubWin (currentsubwin);
-  return -1;
-}
-
-
-extern int DrawNewMarks(sciPointObj * pobj, int n1, int *xm, int *ym, int *DPI)
-{
-  int style = sciGetMarkStyle(pobj);
-  double size = (double) sciGetMarkSize(pobj);
-  int foreground = sciGetMarkForeground(pobj);
-  int background = sciGetMarkBackground(pobj);
-  int i;
-
-  int x[4],v,closeflag=0;
-  double dv;
-  int flagx = 0;
-  int old_foreground;
-
-  int thick;
-  int linestyle[6];
-  int tabulated_marksize[] = {8,10,12,14,18,24};
-  /*   int tabulated_marksize[] = {3,5,7,9,11,13}; */
-  
-  integer verbose = 0,old_thick, old_linestyle[6],narg = 0;
-  int ixres = DPI[0]; /* only the x DPI is used here : */
-    
-  int pixel_offset = CheckPixelStatus();
-  double size_plus_one = 0.;
-  double size_minus_one = 0.;
-
-
-  linestyle[0] = 1;
-  
-  if(sciGetMarkSizeUnit(pobj) == 2){ /* tabulated */ /* size is given relative to the array tabulated_marksize */
-    if( (int) size <= 5){
-      if(style == 0 && size == 0) 
-       size = 1; /* Singularity : To allow the drawing of a single pixel in old mode (tabulated) */
-      else
-       size = tabulated_marksize[(int) size];
-    }   
-    else{
-      size = tabulated_marksize[5];
-    }
-  }
-
-  size_plus_one = size + 1.;
-  size_minus_one = size - 1.;
-
-  /* We get the DPIs value : only the x DPI is used here : */
-  /* we assum we have a square pixel (i.e. xDPI == yDPI or almost) */
-  size = size * (ixres/72.);
-  size_minus_one = size_minus_one * (ixres/72.);
-  size_plus_one  = size_plus_one  * (ixres/72.);
-
-  C2F (dr) ("xget", "foreground", &flagx, &old_foreground, &v, &v, &v,
-           &v, &dv, &dv, &dv, &dv, 5L, 4096);
-  
-  C2F(dr)("xget","thickness",&verbose,&old_thick,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-  
-  C2F(dr)("xget","line style",&verbose,old_linestyle,&narg,&v,&v,&v,&dv,&dv,&dv,&dv,0L,0L);
-
-  for(i=1;i<6;i++) linestyle[i] = old_linestyle[i];
-
-  /* My default for marks drawing */
-  C2F (dr) ("xset", "line style", linestyle, PI0, PI0, PI0, PI0, PI0, PD0,
-           PD0, PD0, PD0, 0L, 0L);
-  
-  thick = sciGetLineWidth (pobj); /* to answer the request from newsgroup to have marks thickness == line thickness every time */
-  if(thick < 1) thick = 1;
-  
-  C2F(dr)("xset","thickness",&thick,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-  /* end of default*/
-
-  if(size < 2){
-    /* represents a . (pixel) with editable foreground */
-    for(i=0;i<n1;i++)
-      {
-       int deux = 2;
-       int xmasterix[2];
-       int ymasterix[2];
-       
-       C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-                 &dv, &dv, &dv, 5L, 4096);
-       C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-                 &dv, &dv, &dv, &dv, 5L, 4096);
-       
-       xmasterix[0] = xm[i];
-       xmasterix[1] = xm[i] + pixel_offset;
-       ymasterix[0] =  ymasterix[1] = ym[i];
-       C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-      }
-    return 0;
-  }
-  
-  foreground = sciGetMarkForeground(pobj);
-  background = sciGetMarkBackground(pobj);
-
-  switch(style){
-  case 0:
-    /* represents a simple full dot with editable foreground */
-    for(i=0;i<n1;i++)
-      DrawMark_FullDot(xm[i], ym[i], size_minus_one, foreground, foreground, pixel_offset);
-    
-    break;
-  case 1:
-    /* represents a plus with editable foreground */
-    for(i=0;i<n1;i++)
-      DrawMark_Plus(xm[i], ym[i], (int)(size/2), foreground, pixel_offset);
-    
-    break;
-  case 2:
-    /* represents a cross with editable foreground */
-    for(i=0;i<n1;i++)
-       DrawMark_Cross(xm[i], ym[i], (int)(size/2), foreground, pixel_offset);
-    
-    break;
-  case 3:
-    
-    /* represents a circle AND a plus within this circle with editable foreground and background */
-    for(i=0;i<n1;i++)
-      {
-       DrawMark_FullDot(xm[i], ym[i], size_minus_one, foreground, background, pixel_offset);
-       DrawMark_Plus(xm[i], ym[i], (int)(size/2), foreground, pixel_offset);
-      }
-    break;
-  case 4:
-    /* represents a diamond with background == foreground  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullDiamond(xm[i], ym[i], (int)(size/2), foreground, foreground);
-
-    break;
-  case 5:
-    /* represents a diamond with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullDiamond(xm[i], ym[i], (int)(size/2), foreground, background);
-    
-    break;
-  case 6:
-    /* represents an upward-pointing triangle with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullTriangleUp(xm[i], ym[i], (int)size, foreground, background);
-    
-    break;
-  case 7:
-    /* represents a downward-pointing triangle with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullTriangleDown(xm[i], ym[i], (int)size, foreground, background);
-    
-    break;
-  case 8:
-    /* represents a diamond with a plus inside with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      {        
-       DrawMark_FullDiamond(xm[i], ym[i], (int)(size/2), foreground, background);
-       DrawMark_Plus(xm[i], ym[i], (int)(size/2), foreground, pixel_offset);
-      }
-    break;
-  case 9:
-    /* represents a circle with editable foreground and background */
-    for(i=0;i<n1;i++)
-      DrawMark_FullDot(xm[i], ym[i], size_minus_one, foreground, background, pixel_offset);
-
-    break;
-  case 10:
-    /* Asterix case : we can modify only the foreground (background changes have no impact) */
-    for(i=0;i<n1;i++)
-      DrawMark_Asterisk(xm[i], ym[i],(int) (size/2), foreground, pixel_offset);
-    
-    break;
-  case 11:
-    /* represents a square with editable foreground and background */
-    for(i=0;i<n1;i++)
-      DrawMark_FullSquare(xm[i], ym[i],(int) size_minus_one, foreground, background, pixel_offset);
-
-    break;
-  case 12:
-    /* represents a right-pointing triangle with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullTriangleRight(xm[i], ym[i],(int) size, foreground, background);
-    
-    break;
-  case 13:
-    /* represents a left-pointing triangle with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullTriangleLeft(xm[i], ym[i],(int) size, foreground, background);
-
-    break;
-  case 14:
-    /* represents a pentagram with both editable foreground and background  */
-    for(i=0;i<n1;i++)
-      DrawMark_FullPentagram(xm[i], ym[i], (int)(size/2), foreground, background);
-
-    break;
-  default:
-    break;
-  }
-  C2F (dr) ("xset", "line style", old_linestyle, PI0, PI0, PI0, PI0, PI0, PD0,
-           PD0, PD0, PD0, 0L, 0L);
-  
-  C2F(dr)("xset","thickness",&old_thick,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-  
-  C2F (dr) ("xset", "dashes", &old_foreground, &old_foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &old_foreground, &old_foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-  
-  return 0; 
-}
-
-
-void DrawMarks3D(sciPointObj *pobj, int n1, int *xm, int *ym, int *DPI)
-{
-  integer v;
-  double dv=0;
-  int x[4], markidsizenew[2];
-
-  if (sciGetIsMark(pobj) == TRUE){
-    x[0] = sciGetMarkForeground(pobj);
-    
-    markidsizenew[0] = sciGetMarkStyle(pobj);
-    markidsizenew[1] = sciGetMarkSize (pobj);
-    
-    C2F (dr) ("xset", "dashes", x, x, x+4, x+4, x+4, &v, &dv,
-             &dv, &dv, &dv, 5L, 4096);
-    C2F (dr) ("xset", "foreground", x, x, x+4, x+4, x+4, &v,
-             &dv, &dv, &dv, &dv, 5L, 4096);
-    
-    C2F (dr) ("xset", "mark", &markidsizenew[0], &markidsizenew[1], PI0, PI0, PI0, PI0, PD0, PD0,
-             PD0, PD0, 0L, 0L);   
-    
-    DrawNewMarks(pobj,n1,xm,ym,DPI);
-  }
-}
-
-
-
-/* F.Leray 25.02.05 */
-/* This function is used to determine how the pixel data*/
-/* is given to Xt method (like XDrawLines) */
-/* 0 : pixel itself */
-/* 1 : pixel's interval */
-/* Explanation :*/
-/* i.e.in X11 (same thing using Win32 driver), with x2=x1+1 and y1=y2, we have : */
-/*   XDrawLine(x1,y1,x1,y1)  does nothing (no pixel lit) */
-/*   XDrawLine(x1,y1,x2,y2)  ONE pixel lit */
-/* BUT the corresponding function with driver Gif (and others?) give us: */
-/* for now (and only for marks), I make a trick using a pixel_offset set to 0 or 1 */
-/* depending on the driver. */
-
-/* slight modif from Bruno : if fact GetDriverId return also 0 */
-/* if gtk is enable so I have added a call to withgtk to get the */
-/* the good pixel_offset */
-extern int C2F(withgtk)(int *rep);
-
-int CheckPixelStatus(void)
-{
-  if(GetDriverId() == 0) /* X11 or Win32 driver or Gtk driver */
-    { 
-      int irep;
-      C2F(withgtk)(&irep);
-      if (irep)
-       return 0;
-      else
-       return 1;
+      }
+      break;
+    case  SCI_SEGS: 
+      N=pSEGS_FEATURE (psonstmp->pointobj)->Nbr1 / 2 ;
+      break;
+    case  SCI_RECTANGLE: 
+      N = 4;
+      break;
+    case SCI_AGREG:
+      N =  Merge3dDimension(psonstmp->pointobj);
+      break;
+    default:
+      N=0;
     }
-  else
-    return 0;
-}
-
-
-
-/* center : xmi,ymi */
-/* diameter : size */
-int DrawMark_FullDot(int xmi, int ymi, double size, int foreground, int background, int pixel_offset)
-{
-  int x1 = (int) (xmi - size/2);
-  int yy1= (int) (ymi - size/2);
-  int w1 = (int) size+pixel_offset;
-  int h1 = (int) size+pixel_offset; 
-  char str[2] = "xv";
-  int x[4];
-  integer v;
-  double dv;
-
-  integer angle1 = 0;
-  integer angle2 = 64*360;
+    q+=N;
+    psonstmp = psonstmp->pnext;
+  }
 
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-  
-  C2F (dr) ("xfarc", str, &x1, &yy1, &w1, &h1, &angle1, &angle2, PD0, PD0, PD0,PD0, 5L, 0L);
-  
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xarc", str, &x1, &yy1, &w1, &h1, &angle1, &angle2, PD0, PD0, PD0,PD0, 5L, 0L);
-  
-  return 0;
+  return q;
 }
 
-/* center : xmi,ymi */
-/* "+" half-size (minus centered pixel) : size */
-int DrawMark_Plus(int xmi, int ymi, int size, int foreground, int pixel_offset)
+int ChildrenCounter(sciPointObj *pparent)
 {
-  int deux = 2;
-  int xmasterix[2];
-  int ymasterix[2];
-  int x[4],v,closeflag=0;
-  double dv;
-  
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
+  int N,q=0;
+  sciSons * psonstmp = sciGetSons (pparent);
   
-  /* the "+" */
-  xmasterix[0] = xmi -((int) size) ;
-  xmasterix[1] = xmi +(int) size + pixel_offset;
-  ymasterix[0] =       ymasterix[1] = ymi;
-/*   C2F(dr)("xsegs","v", xmasterix, ymasterix, &deux,&foreground,&closeflag,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
+  while (psonstmp != (sciSons *) NULL) {   
+    switch (sciGetEntityType (psonstmp->pointobj)) {  
+    case SCI_SURFACE:
+      N=1;
+      break;
+    case  SCI_POLYLINE:
+      N = 1; 
+      break;
+    case  SCI_SEGS: 
+      N=1;
+      break;
+    case  SCI_RECTANGLE: 
+      N = 1;
+      break;
+    case SCI_AGREG:
+      N = ChildrenCounter(psonstmp->pointobj);
+      break;
+    default:
+      N=0;
+    }
+    q+=N;
+    psonstmp = psonstmp->pnext;
+  }
 
-  
-  xmasterix[0] = xmasterix[1] = xmi;
-  ymasterix[0] = ymi - (int) size;
-  ymasterix[1] = ymi + (int) size + pixel_offset;
-/*   C2F(dr)("xsegs","v", xmasterix, ymasterix, &deux,&foreground,&closeflag,PI0,PD0,PD0,PD0,PD0,0L,0L); */
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-   
-  return 0;
+  return q;
 }
 
-/* center : xmi,ymi */
-/* "x" half-size (minus centered pixel) : size */
-int DrawMark_Cross(int xmi, int ymi, int size, int foreground, int pixel_offset)
-{
-  int deux = 2;
-  int xmasterix[2];
-  int ymasterix[2];
-  int x[4],v,closeflag=0;
-  double dv;
-  
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-  
-  /* the "/" */
-  xmasterix[0] = (int) (xmi - size);
-  xmasterix[1] = (int) (xmi + size + pixel_offset);
-  ymasterix[0] = (int) (ymi + size);
-  ymasterix[1] = (int) (ymi - size - pixel_offset);
-
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-  /* end */
-       
-  /* the "\" */
-  xmasterix[0] = (int) (xmi - size);
-  xmasterix[1] = (int) (xmi + size + pixel_offset);
-  ymasterix[0] = (int) (ymi - size);
-  ymasterix[1] = (int) (ymi + size + pixel_offset);
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-  /* end */
-
-  return 0;
-}
 
-/* center : xmi,ymi */
-/* represents a diamond with both editable foreground and background  */
-int DrawMark_FullDiamond(int xmi, int ymi, int size, int foreground, int background)
+void Merge3dBuildTable(sciPointObj *pparent, int *index_in_entity, long *from_entity, int *pos)
 {
-  int quatre = 4, un=1;
-  int xmdiamond[4];
-  int ymdiamond[4];
-  int x[4],v;
-  double dv;
-       
-  xmdiamond[0] = xmi - size;
-  xmdiamond[1] = xmi;
-  xmdiamond[2] = xmi + size;
-  xmdiamond[3] = xmi;
-       
-  ymdiamond[0] = ymi;
-  ymdiamond[1] = ymi + size;
-  ymdiamond[2] = ymi;
-  ymdiamond[3] = ymi - size;
-  
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xarea", "v", &quatre, xmdiamond, ymdiamond, &un, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
-  
-  if(foreground != background){
-    C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-             &dv, &dv, &dv, 5L, 4096);
-    C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-             &dv, &dv, &dv, &dv, 5L, 4096);
-    
-    C2F (dr) ("xlines", "xv", &quatre, xmdiamond, ymdiamond, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-  }
-  
-  return 0;
-}
-
+  sciSons *psonstmp;
+  int i,N;
 
-int DrawMark_FullTriangleUp(int xmi, int ymi, int size, int foreground, int background)
-{
-  int trois = 3, un=1;
-  int xmtriangle[3];
-  int ymtriangle[3];
-  int x[4],v;
-  double dv;
-   
-  xmtriangle[0] = (int) (xmi - size/2);
-  xmtriangle[1] = (int) (xmi + size/2);
-  xmtriangle[2] = xmi;
-       
-  ymtriangle[0] = (int) (ymi + size/3);
-  ymtriangle[1] = (int) (ymi + size/3);
-  ymtriangle[2] = (int) (ymi - 2*size/3);
-
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xarea", "v", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
-       
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
+  psonstmp = sciGetSons (pparent);
 
-  if(foreground != background){
-    C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-             &dv, &dv, &dv, &dv, 5L, 4096);
-    
-    C2F (dr) ("xlines", "xv", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
+  while (psonstmp != (sciSons *) NULL) {   
+    switch (sciGetEntityType (psonstmp->pointobj)) {  
+    case SCI_SURFACE:
+      if (pSURFACE_FEATURE (psonstmp->pointobj)->typeof3d == SCI_PLOT3D) 
+       N=(pSURFACE_FEATURE (psonstmp->pointobj)->dimzx-1)*(pSURFACE_FEATURE (psonstmp->pointobj)->dimzy-1);
+      else
+       N = pSURFACE_FEATURE (psonstmp->pointobj)->dimzy;
+      break;
+    case  SCI_POLYLINE:
+      if ( pPOLYLINE_FEATURE(psonstmp->pointobj)->n1 == 0 )
+      {
+        N = 0 ;
+      }
+      else if (pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 5)
+      {/*polyline*/
+       N = pPOLYLINE_FEATURE (psonstmp->pointobj)->n1-1;
+       if ((pPOLYLINE_FEATURE (psonstmp->pointobj)->plot != 2) && 
+           (sciGetIsMark((sciPointObj *)psonstmp->pointobj) == 1))
+        {
+         N = N + 1 ;
+        }
+      }
+      else /* patch */
+      {
+       N = 1 ;
+      }
+      break;
+    case  SCI_SEGS: 
+      N=pSEGS_FEATURE (psonstmp->pointobj)->Nbr1/2;
+      break;
+    case  SCI_RECTANGLE: 
+      N = 4;
+      break;
+    case SCI_AGREG:
+      Merge3dBuildTable(psonstmp->pointobj, index_in_entity, from_entity, pos);
+      break;
+    default:
+      N = 0;
+    }
+    if (sciGetEntityType (psonstmp->pointobj) != SCI_AGREG)
+      for (i=0 ; i<N; i++) {
+       index_in_entity[*pos]=i;
+       from_entity[*pos]=(long) sciGetHandle (psonstmp->pointobj);
+       *pos=*pos+1;
+      }
+    psonstmp = psonstmp->pnext;
   }
-  
-  return 0;
 }
-      
 
-int DrawMark_FullTriangleDown(int xmi, int ymi, int size, int foreground, int background)
+
+void Merge3d(sciPointObj *psubwin)
 {
-  int trois = 3, un=1;
-  int xmtriangle[3];
-  int ymtriangle[3];
-  int x[4],v;
-  double dv;
-       
-  xmtriangle[0] = (int) (xmi - size/2);
-  xmtriangle[1] = (int) (xmi + size/2);
-  xmtriangle[2] = (int) (xmi);
+  integer q,k; 
+  sciPointObj *pmerge; 
+  int *index_in_entity;
+  long *from_entity;
   
-  ymtriangle[0] = (int) (ymi - size/3);
-  ymtriangle[1] = (int) (ymi - size/3);
-  ymtriangle[2] = (int) (ymi + 2*size/3);
+  if(sciGetEntityType (psubwin) != SCI_SUBWIN) return; 
+  if ((pmerge= sciGetMerge(psubwin)) != (sciPointObj *) NULL)
+    DestroyMerge(pmerge); 
   
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
+  /* ========================================================================
+   * Compute the number of facets, segments,... included in all the subwin 
+   * children
+   * ========================================================================*/
   
-  C2F (dr) ("xarea", "v", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
   
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
+  q =  Merge3dDimension(psubwin);
   
-  C2F (dr) ("xlines", "xv", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
   
-  return 0;
-}
-      
-int DrawMark_Asterisk(int xmi, int ymi, int size, int foreground, int pixel_offset)
-{
-  int deux = 2;
-  int xmasterix[2];
-  int ymasterix[2];
-  int sizecross = (int)(0.8*size);
-  int x[4],v,closeflag=0;
-  double dv;
+  /* ========================================================================
+   * allocate tables for index and handles
+   * ========================================================================*/
   
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  /* the "+" */
-  xmasterix[0] = xmi - size;
-  xmasterix[1] = xmi + size +pixel_offset;
-  ymasterix[0] = ymasterix[1] = ymi;
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-       
-  xmasterix[0] = xmasterix[1] = xmi;
-  ymasterix[0] = ymi - size;
-  ymasterix[1] = ymi + size +pixel_offset;
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-  /* end */
-
-  /* the "/" */
-  xmasterix[0] =(int)( xmi - ceil(sizecross));
-  xmasterix[1] =(int)( xmi + ceil(sizecross)+pixel_offset);
-  ymasterix[0] = (int)(ymi + ceil(sizecross));
-  ymasterix[1] = (int)(ymi - ceil(sizecross)-pixel_offset);
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-  /* end */
-       
-  /* the "\" */
-  xmasterix[0] = (int)(xmi - ceil(sizecross));
-  xmasterix[1] = (int)(xmi + ceil(sizecross)+pixel_offset);
-  ymasterix[0] = (int)(ymi - ceil(sizecross));
-  ymasterix[1] = (int)(ymi + ceil(sizecross)+pixel_offset);
-  C2F (dr) ("xlines", "xv", &deux, xmasterix, ymasterix, &closeflag, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-  /* end */
-
-  return 0;
-}
-
-
-int DrawMark_FullSquare(int xmi, int ymi, int size, int foreground, int background, int pixel_offset)
-{
-  int x1 = xmi - size/2;
-  int yy1= ymi - size/2;
-  int w1 = size;
-  int h1 = size;
-  char str[2] = "xv";
-  int x[4],v;
-  double dv;
+  /* q now contains the total number of elements */
+  if ((index_in_entity = (int *) MALLOC (q * sizeof (int))) == (int *)NULL) {
+    sciprint("Merge3d : not enough memory to allocate \n");
+    return;
+  }
+  if ((from_entity   = (long *) MALLOC (q * sizeof (long))) == (long *) NULL) {
+    sciprint("Merge3d : not enough memory to allocate \n");
+    FREE(index_in_entity);
+  }
   
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xfrect", str, &x1, &yy1, &w1, &h1, PI0, PI0, PD0, PD0, PD0,PD0, 5L, 0L);
-       
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xrect", str, &x1, &yy1, &w1, &h1, PI0, PI0, PD0, PD0, PD0,PD0, 5L, 0L);
-       
-
-  return 0;
-}
-
-
-int DrawMark_FullTriangleRight(int xmi, int ymi, int size, int foreground, int background)
-{
-  int trois = 3, un=1;
-  int xmtriangle[3];
-  int ymtriangle[3];
-  int x[4],v;
-  double dv;
+  /* ========================================================================
+   * fill the index and handles tables
+   * ========================================================================*/
+  k=0;
+  Merge3dBuildTable(psubwin, index_in_entity, from_entity, &k);
   
-  xmtriangle[0] = (int) (xmi - size/3);
-  xmtriangle[1] = (int) (xmi - size/3);
-  xmtriangle[2] = (int) (xmi + 2*size/3);
-       
-  ymtriangle[0] = (int) (ymi - size/2);
-  ymtriangle[1] = (int) (ymi + size/2);
-  ymtriangle[2] = ymi;
-       
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xarea", "v", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
-
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-
-  C2F (dr) ("xlines", "xv", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-
-  return 0;
-}
-
-
-int DrawMark_FullTriangleLeft(int xmi, int ymi, int size, int foreground, int background)
-{
-
-  int trois = 3, un=1;
-  int xmtriangle[3];
-  int ymtriangle[3];
-  int x[4],v;
-  double dv;
+  /* ========================================================================
+   * create the Merge data structure
+   * ========================================================================*/
   
-  xmtriangle[0] = (int) (xmi + size/3);
-  xmtriangle[1] = (int) (xmi + size/3);
-  xmtriangle[2] = (int) (xmi - 2*size/3);
-       
-  ymtriangle[0] = (int) (ymi - size/2);
-  ymtriangle[1] = (int) (ymi + size/2);
-  ymtriangle[2] = ymi;
-
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xarea", "v", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
-
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-
-  C2F (dr) ("xlines", "xv", &trois, xmtriangle, ymtriangle, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
-
+  if ((pmerge=ConstructMerge ((sciPointObj *) psubwin,q,index_in_entity,from_entity)) == (sciPointObj *) NULL) {
+    FREE(index_in_entity);
+    FREE(from_entity);
+    sciprint ("\r\n No merge supported");}
+  else /* inform the subwindow to display Merge instead of individual children */
+    pSUBWIN_FEATURE (psubwin)->facetmerge = TRUE;
   
-  return 0;
 }
 
-
-int DrawMark_FullPentagram(int xmi, int ymi, int size, int foreground, int background)
+/*------------------------------------------------------------------------------------------*/
+/**
+ * draw the figure number numFigure.
+ */
+void sciDrawFigure( int numFigure )
 {
-  int dix= 10, un=1;
-  int xmpoints1[5],ympoints1[5];
-  int xmpoints2[5],ympoints2[5];
-  int xmpoints[10], ympoints[10];
-  int x[4],v;
-  double dv;
-       
-  double r2 = size*cos(72*M_PI/180)/cos(36*M_PI/180);
-
-  xmpoints1[0] = (int)(xmi - size*cos(54*M_PI/180));
-  ympoints1[0] = (int)(ymi + size*sin(54*M_PI/180));
-       
-  xmpoints1[1] = (int)(xmi + size*cos(54*M_PI/180));
-  ympoints1[1] = (int)(ymi + size*sin(54*M_PI/180));
-       
-  xmpoints1[2] = (int)(xmi + (xmpoints1[1] - xmi) *cos(72*M_PI/180) + (ympoints1[1] - ymi) *sin(72*M_PI/180));
-  ympoints1[2] = (int)(ymi - (xmpoints1[1] - xmi) *sin(72*M_PI/180) + (ympoints1[1] - ymi) *cos(72*M_PI/180));
-
-  xmpoints1[3] = xmi;
-  ympoints1[3] = ymi - size;
-
-  xmpoints1[4] = (int)(xmi + (xmpoints1[0] - xmi) *cos(-72*M_PI/180) + (ympoints1[0] - ymi) *sin(-72*M_PI/180));
-  ympoints1[4] = (int)(ymi - (xmpoints1[0] - xmi) *sin(-72*M_PI/180) + (ympoints1[0] - ymi) *cos(-72*M_PI/180));
-
-       
-  xmpoints2[0] = (int)( xmi - r2*sin(36*M_PI/180));
-  ympoints2[0] = (int)(ymi - size*cos(72*M_PI/180));
-
-  xmpoints2[1] = (int)(xmi + r2*sin(36*M_PI/180));
-  ympoints2[1] = (int)(ymi - size*cos(72*M_PI/180));
-
-  xmpoints2[2] = (int)(xmi + (xmpoints2[1] - xmi)*cos(-72*M_PI/180) + (ympoints2[1] - ymi) *sin(-72*M_PI/180));
-  ympoints2[2] = (int)(ymi - (xmpoints2[1] - xmi)*sin(-72*M_PI/180) + (ympoints2[1] - ymi) *cos(-72*M_PI/180));
-
-  xmpoints2[3] = xmi;
-  ympoints2[3] = (int)(ymi + r2);
-
-  xmpoints2[4] = (int)(xmi + (xmpoints2[0] - xmi)*cos(72*M_PI/180) + (ympoints2[0] - ymi) *sin(72*M_PI/180));
-  ympoints2[4] = (int)(ymi - (xmpoints2[0] - xmi)*sin(72*M_PI/180) + (ympoints2[0] - ymi) *cos(72*M_PI/180));
-
-       
-  xmpoints[0] = xmpoints2[4];
-  ympoints[0] = ympoints2[4];
-
-  xmpoints[1] = xmpoints1[0];
-  ympoints[1] = ympoints1[0];
-
-  xmpoints[2] = xmpoints2[3];
-  ympoints[2] = ympoints2[3];
-
-  xmpoints[3] = xmpoints1[1];
-  ympoints[3] = ympoints1[1];
-
-  xmpoints[4] = xmpoints2[2];
-  ympoints[4] = ympoints2[2];
+  int curFigure = sciGetNumFigure( sciGetCurrentFigure() ) ;
+  sciSetUsedWindow( numFigure ) ;
+  sciDrawObj( sciGetCurrentFigure() ) ;
+  sciSetUsedWindow( curFigure ) ;
+}
+/*------------------------------------------------------------------------------------------*/
 
-  xmpoints[5] = xmpoints1[2];
-  ympoints[5] = ympoints1[2];
+/*-------------------------------------------------------------------------------------------*/
+/* sciRefreshObj                                                                             */
+/* draw an object but before select the rigth figure for display                             */
+/*-------------------------------------------------------------------------------------------*/
+int sciRefreshObj( sciPointObj * pobj )
+{
+  
+  int parentId = sciGetNum( sciGetParentFigure( pobj ) ) ;
+  int currentId             ;
+  int status                ;
+  int verboseGet        = 0 ;
+  int iDontKnowWhatItIs     ;
+  /* get current Id in ScilabXgc */
+  C2F (dr) ("xget", "window",&verboseGet,&currentId,&iDontKnowWhatItIs,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
 
-  xmpoints[6] = xmpoints2[1];
-  ympoints[6] = ympoints2[1];
+  /* set the parent figure of the object as the current figure */
+  if ( parentId != currentId )
+  {
+    C2F (dr) ("xset", "window",&parentId,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+  }
+  
+  /* draw the object */
+  status = sciDrawObjIfRequired( pobj ) ;
 
-  xmpoints[7] = xmpoints1[3];
-  ympoints[7] = ympoints1[3];
+  /* set back the values */
+  if ( parentId != currentId )
+  {
+    C2F (dr) ("xset", "window",&currentId,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
+  }
 
-  xmpoints[8] = xmpoints2[0];
-  ympoints[8] = ympoints2[0];
+  return status ;
+  
+  
+}
 
-  xmpoints[9] = xmpoints1[4];
-  ympoints[9] = ympoints1[4];
 
 
-  C2F (dr) ("xset", "dashes", &background, &background, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &background, &background, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
-       
-  C2F (dr) ("xarea", "v", &dix, xmpoints, ympoints, &un, PI0, PI0, PD0, PD0, PD0, PD0, 5L,0L);
-       
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, x+4, x+4, x+4, &v, &dv,
-           &dv, &dv, &dv, 5L, 4096);
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, x+4, x+4, x+4, &v,
-           &dv, &dv, &dv, &dv, 5L, 4096);
+/**sciDrawObjIfRequired
+ * Draws Object (only the basic  graphicobject under subwindows) in its SubWindow or figure
+ * if and only if pFIGURE_FEATURE(pobj)->auto_redraw == TRUE !!
+ * Only used inside High Level functions calls (sucha as plot2d, plot3d...)
+ * @param sciPointObj * pobj: the pointer to the entity
+ * @return  int 0 if OK, -1 if not
+ */
+int
+sciDrawObjIfRequired (sciPointObj * pobj)
+{
+  sciPointObj * pfigure = sciGetParentFigure(pobj);
 
-  C2F (dr) ("xlines", "xv", &dix, xmpoints, ympoints, &un, PI0, PI0, PD0, PD0, PD0, PD0,6L,2L);
+  if( pFIGURE_FEATURE(pfigure)->auto_redraw && pFIGURE_FEATURE(pfigure)->visible )
+  {
+    sciDrawObj(pobj);
+  }
 
   return 0;
 }
 
-
-/* we draw marks in pixel */
-/* Returns the DPI depending on the used driver */
-int GetDPIFromDriver(int * DPI)
+/**sciDrawObj
+ * Draws Object (only the basic  graphicobject under subwindows) in its SubWindow or figure
+ * @param sciPointObj * pobj: the pointer to the entity
+ * @return  int 0 if OK, -1 if not
+ */
+int
+sciDrawObj (sciPointObj * pobj)
 {
-  int driver = GetDriverId(); /* return the first letter of the driver name (see XCall.c) */
-  int succeed = 0;
-  int ixres, iyres;
   
-  switch(driver)
+  /*sciPointObj * curSubWin = sciGetSelectedSubWin( sciGetCurrentFigure() ) ;*/
+  
+  /* driver test */  
+  if((GetDriverId() != 0) && ( isGraphicSessionOpened() )){
+    return -1;
+  }
+
+  switch (sciGetEntityType (pobj))
     {
-    case 0: 
-         if(WindowsPrintScreen == 1)
-          {
-         ixres = Printer_XRes;
-         iyres = Printer_YRes;
-                succeed = 1;
-          }
-         else
-          {
-        succeed = GetScreenDPI(&ixres,&iyres);
-        if(succeed == -1){
-            ixres = (int)72.; /* default value*/
-            iyres = (int)72.; /* default value*/
-        }
-          }
+    case SCI_FIGURE:
+      return drawFigureEntity( pobj ) ;
+      break;
+    case SCI_SUBWIN:
+      return drawSubWinEntity( pobj ) ;
+      break ;
+    case SCI_AGREG:
+      return drawCompoundEntity( pobj ) ;
+      break;
+    case SCI_LEGEND:
+      return drawLegendEntity( pobj ) ;
+      break;   
+    case SCI_FEC:
+      return drawFecEntity( pobj ) ;
+      break;      
+    case SCI_SEGS:
+      return drawSegsEntity( pobj ) ;
+      break;
+    case SCI_GRAYPLOT:
+      return drawGrayplotEntity( pobj ) ;
+      break;
+    case SCI_POLYLINE:   
+      return drawPolylineEntity( pobj ) ;
+      break;
+    case SCI_ARC:
+      return drawArcEntity( pobj ) ;
       break;
-    case 1: /* Pos */
-      /*       printf("DRIVERS POS enabled -- -- -- --\n"); */
-      /* when using Pos driver, the output file is 6000x4240 pixels */
-      /* computed DPI: height : 6000/(30cm/2.54) = 508 ; width: 4240/(21.20/2.54) = 508 */
-      ixres = (int)(524.*1.5);
-      iyres = (int)(524.*1.5);
+    case SCI_RECTANGLE:
+      return drawRectangleEntity( pobj ) ;
+      break;
+    case SCI_TEXT:
+      return drawTextEntity( pobj ) ;
+      break;
+    case SCI_AXES:
+      return drawAxesEntity(pobj) ;
       break;
-    case 2: /* Fig. */
-      /*       printf("DRIVERS FIG enabled -- -- -- --\n"); */
-      /* when using Pos driver, the output file is 6000x4240 pixels */
-      /* computed DPI: height : 9600/(8inches) = 1200 ; width: 6784/(5.7inches) = 1190 */
-      ixres = (int)1200.;
-      iyres = (int)1190.;
+    case SCI_MERGE:
+      return drawMergeEntity(pobj) ;
+      break ;
+    case SCI_SURFACE:
+      return drawSurfaceEntity(pobj) ;
       break;
-    case 3: /* Gif & PPM driver */ /* NOT SURE: may be 72. avery time... */
+    case SCI_LIGHT:
+    case SCI_PANNER:
+    case SCI_SBH:
+    case SCI_SBV:
+    case SCI_MENU:
+    case SCI_MENUCONTEXT:
+    case SCI_STATUSB:
     default:
-      succeed = GetScreenDPI(&ixres,&iyres);
-      if(succeed == -1){
-       ixres = (int)72.; /* default value*/    
-       iyres = (int)72.; /* default value*/
-      }
+      return -1;
       break;
     }
+  /*sciSetSelectedSubWin (curSubWin);*/
+  return -1;
+}
 
-  DPI[0] = ixres;
-  DPI[1] = iyres;
 
-  return 0;
-}
 
 
+/* F.Leray 25.02.05 */
+/* This function is used to determine how the pixel data*/
+/* is given to Xt method (like XDrawLines) */
+/* 0 : pixel itself */
+/* 1 : pixel's interval */
+/* Explanation :*/
+/* i.e.in X11 (same thing using Win32 driver), with x2=x1+1 and y1=y2, we have : */
+/*   XDrawLine(x1,y1,x1,y1)  does nothing (no pixel lit) */
+/*   XDrawLine(x1,y1,x2,y2)  ONE pixel lit */
+/* BUT the corresponding function with driver Gif (and others?) give us: */
+/* for now (and only for marks), I make a trick using a pixel_offset set to 0 or 1 */
+/* depending on the driver. */
+
+/* slight modif from Bruno : if fact GetDriverId return also 0 */
+/* if gtk is enable so I have added a call to withgtk to get the */
+/* the good pixel_offset */
+
 
 
 int AdaptGraduationsOnYBottomLeft(int iof, int x, int y, int size, integer *Ticsdir, int *fontid, sciPointObj * psubwin, double yminval, double ymaxval, double fx, double fy, double fz)
@@ -9476,7 +4596,9 @@ int AdaptGraduationsOnYBottomLeft(int iof, int x, int y, int size, integer *Tics
   integer barlengthx = 0,barlengthy = 0;
   integer rect[4],posi[2];
   integer textcolor = -1;
-  int logrect[4],XX,YY;
+  int logrect[4] ;
+  int XX = 0 ;
+  int YY = 0 ;
   int pas;
   double fact_h = 1.5, fact_w = 1.5;
   int compteur = 0;
@@ -9485,7 +4607,7 @@ int AdaptGraduationsOnYBottomLeft(int iof, int x, int y, int size, integer *Tics
   
   sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
   
-  for(i=0;i<4;i++) old_rect[i] = 0; /* Init. old_rect to force first grad. to be displayed */
+  for(i=0;i<4;i++) { old_rect[i] = 0 ; } /* Init. old_rect to force first grad. to be displayed */
   
   lastyindex = ppsubwin->axes.nygrads - 1;
   
@@ -9508,12 +4630,6 @@ int AdaptGraduationsOnYBottomLeft(int iof, int x, int y, int size, integer *Tics
       char foo[256];
       double ytmp = ppsubwin->axes.ygrads[i];
                  
-/*       if(ytmp<yminval || ytmp>ymaxval)  */
-/*     { */
-/*       /\*   sciprint("je rejete la valeur: %lf\n\n",xtmp); *\/ */
-/*       continue; /\* cas ou TL est ON et on a des graduations qui ne seront pas affichees de tte facon *\/ */
-/*       /\* donc autant ne pas aller plus loin dans l'algo... *\/ */
-/*     } */
                  
       sprintf(foo,c_format,ytmp);
 
@@ -9532,18 +4648,6 @@ int AdaptGraduationsOnYBottomLeft(int iof, int x, int y, int size, integer *Tics
 
       C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
       C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
-      
-
-/*       if (IsDownAxes(psubwin)){ */
-/*     vx[1]=vx[0]; */
-/*     vy[1]=vy[0]+iof/2; */
-/*     posi[0] = inint(xm-rect[2]/2);  */
-/*     posi[1]=inint( vy[0] + iof + rect[3]);} */
-/*       else{ */
-/*     vx[1]=vx[0]+barlengthx; */
-/*     vy[1]=vy[0]+barlengthy; */
-/*     posi[0] = inint( xm+2*barlengthx); */
-/*     posi[1]=inint( ym + 2*barlengthy + rect[3]);} */
                      
       
       if (IsDownAxes(psubwin)){
@@ -9959,7 +5063,9 @@ int AdaptGraduationsOnYBottomRight(int iof, int x, int y, int size, integer *Tic
   integer barlengthx = 0,barlengthy = 0;
   integer rect[4],posi[2]; 
   integer textcolor = -1;
-  int logrect[4],XX,YY;
+  int logrect[4] ;
+  int XX = 0 ;
+  int YY = 0 ;
   int pas;
   double fact_h = 1.5, fact_w = 1.5;
   int compteur = 0;
@@ -9991,13 +5097,6 @@ int AdaptGraduationsOnYBottomRight(int iof, int x, int y, int size, integer *Tic
       char foo[256]; 
       double ytmp = ppsubwin->axes.ygrads[i];
                  
-/*       if(ytmp<yminval || ytmp>ymaxval)  */
-/*     { */
-/*       /\*   sciprint("je rejete la valeur: %lf\n\n",xtmp); *\/ */
-/*       continue; /\* cas ou TL est ON et on a des graduations qui ne seront pas affichees de tte facon *\/ */
-/*       /\* donc autant ne pas aller plus loin dans l'algo... *\/ */
-/*     } */
-                 
       sprintf(foo,c_format,ytmp);
 
       /***************************************************************/
@@ -10189,7 +5288,9 @@ int AdaptGraduationsOnXBottomRight(int iof, int x, int y, int size, integer *Tic
   integer barlengthx = 0,barlengthy = 0;
   integer rect[4],posi[2]; 
   integer textcolor = -1;
-  int logrect[4],XX,YY;
+  int logrect[4] ;
+  int XX = 0;
+  int YY = 0 ;
   int pas;
   double fact_h = 1.5, fact_w = 1.5;
   int compteur = 0;
@@ -10221,13 +5322,6 @@ int AdaptGraduationsOnXBottomRight(int iof, int x, int y, int size, integer *Tic
       char foo[256]; 
       double xtmp = ppsubwin->axes.xgrads[i];
                  
-/*       if(xtmp<xminval || xtmp>xmaxval)  */
-/*     { */
-/*       /\*   sciprint("je rejete la valeur: %lf\n\n",xtmp); *\/ */
-/*       continue; /\* cas ou TL est ON et on a des graduations qui ne seront pas affichees de tte facon *\/ */
-/*       /\* donc autant ne pas aller plus loin dans l'algo... *\/ */
-/*     } */
-                 
       sprintf(foo,c_format,xtmp);
 
       /***************************************************************/
@@ -10422,7 +5516,9 @@ int AdaptGraduationsOnZ(int x, int y, int size, integer *Ticsdir, int *fontid, s
   integer barlengthx = 0,barlengthy = 0;
   integer rect[4],posi[2]; 
   integer textcolor = -1;
-  int logrect[4],XX,YY;
+  int logrect[4] ;
+  int XX = 0 ;
+  int YY = 0 ;
   int pas;
   double fact_h = 1.5, fact_w = 1.;
   int compteur;
@@ -10455,15 +5551,6 @@ int AdaptGraduationsOnZ(int x, int y, int size, integer *Ticsdir, int *fontid, s
     {
       char foo[256];
       double ztmp = ppsubwin->axes.zgrads[i];
-      
-/*       if(ztmp<zminval || ztmp>zmaxval) */
-/*     { */
-/*       /\*   sciprint("je rejete la valeur: %lf\n\n",xtmp); *\/ */
-/*       continue; /\* cas ou TL est ON et on a des graduations qui ne seront pas affichees de tte facon *\/ */
-/*       /\* donc autant ne pas aller plus loin dans l'algo... *\/ */
-/*     } */
-      
-      /*       sprintf(foo,c_format,ztmp); */
 
       sprintf(foo,c_format,ztmp);
       
@@ -10682,146 +5769,6 @@ int ChooseFormatForOneGrad(char *c_format, double *grad)
 }
 
 
-/* Vertices * Tete = NULL; */
-
-int Store3DPixelValues(sciPointObj * pobj, int xm, int ym, double x, double y, double z)
-{
-
-  sciPointObj * psubwin = sciGetParentSubwin(pobj);
-  sciSubWindow *ppsubwin = pSUBWIN_FEATURE(psubwin);
-
-  if(GlobalFlag_Zoom3dOn == 1){
-    Vertices * pCurrent = ppsubwin->vertices_list;
-    
-    if (pCurrent != NULL) {
-      
-      pCurrent = pHead;
-      
-      if(( pCurrent->pNext = (Vertices*) MALLOC(sizeof(Vertices))) == NULL){
-       printf("Allocation failed for vertices when zoom called\n");
-       return -1;
-      }
-      
-      /*       pCurrent->pNext = NewVertices; */
-      
-      pCurrent->pNext->pNext = NULL;
-      
-      pCurrent->pNext->value_xm = xm;
-      pCurrent->pNext->value_ym = ym;
-      pCurrent->pNext->value_x = x;
-      pCurrent->pNext->value_y = y;
-      pCurrent->pNext->value_z = z;
-
-      pHead = pCurrent->pNext;
-
-    }
-    else
-      { /* first element is created */
-       if((ppsubwin->vertices_list = (Vertices*) MALLOC(sizeof(Vertices))) == NULL){
-         printf("Allocation failed for vertices when zoom called\n");
-         return -1;
-       }
-       
-       ppsubwin->vertices_list->value_xm = xm;
-       ppsubwin->vertices_list->value_ym = ym;
-       ppsubwin->vertices_list->value_x = x;
-       ppsubwin->vertices_list->value_y = y;
-       ppsubwin->vertices_list->value_z = z;
-       
-       ppsubwin->vertices_list->pNext = NULL;
-
-       pHead = ppsubwin->vertices_list;
-
-      }
-    index_vertex++;
-  }
-  
-  return 0;
-}
-
-
-int SetMinMaxVertices(Vertices *vertices_list, double *xmin, double *ymin, double *zmin,double *xmax, double *ymax, double *zmax)
-{ 
-  Vertices * pCurrent = vertices_list;
-
-  *xmin = *xmax = vertices_list->value_x;
-  *ymin = *ymax = vertices_list->value_y;
-  *zmin = *zmax = vertices_list->value_z;
-  
-  while (pCurrent != NULL) {
-    if(pCurrent->value_x >  *xmin) *xmin = pCurrent->value_x;
-    if(pCurrent->value_y >  *ymin) *ymin = pCurrent->value_y;
-    if(pCurrent->value_z >  *zmin) *zmin = pCurrent->value_z;
-    
-    if(pCurrent->value_x <  *xmax) *xmax = pCurrent->value_x;
-    if(pCurrent->value_y <  *ymax) *ymax = pCurrent->value_y;
-    if(pCurrent->value_z <  *zmax) *zmax = pCurrent->value_z;
-    
-    pCurrent = pCurrent->pNext;
-  }
-  
-  return 0;
-}
-
-int GetVerticesAt(Vertices *vertices_list, int *xm, int *ym, double *x, double *y, double *z)
-{
-  Vertices * pCurrent = vertices_list;
-/*   int i; */
-
- /*  for(i=0;i<index;i++){ */
-/*     pCurrent = pCurrent->pNext; */
-/*     if(pCurrent == NULL){ */
-/*       /\*       printf("pCurrent est nul et i vaut: %d\n",i); *\/ */
-/*       return -1; */
-/*     } */
-/*   } */
-  
-  if(pHead2 == (Vertices *) NULL)
-    pHead2 = pCurrent;
-  
-  *xm = pHead2->value_xm;
-  *ym = pHead2->value_ym;
-  *x  = pHead2->value_x;
-  *y  = pHead2->value_y;
-  *z  = pHead2->value_z;
-  
-  pHead2 = pHead2->pNext;
-  
-  return 0;
-}     
-
-
-int RemoveNext(Vertices *pCurrent)
-{
-  Vertices * DeletedElement = pCurrent->pNext;
-  Vertices * pNextNext =  pCurrent->pNext->pNext;
-
-  FREE(DeletedElement); DeletedElement = (Vertices *) NULL;
-  
-  pCurrent->pNext = pNextNext;
-
-  return 0;
-}
-
-int FreeVertices(sciPointObj * psubwin)
-{
-  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
-  Vertices * pCurrent = ppsubwin->vertices_list;
-  
-  if (pCurrent != NULL) {
-    
-    /*pCurrent = Tete; */
-    while (pCurrent->pNext != NULL){
-      RemoveNext(pCurrent);
-    }
-    FREE(ppsubwin->vertices_list); ppsubwin->vertices_list = (Vertices *) NULL;
-  }
-  
-  pHead = (Vertices *) NULL;
-  pHead2 = (Vertices *) NULL;
-
-  return 0;
-}
 
 /*-------------------------------------------------------------------------------------*/
 /* compute the 8 vertices (xbox[i],ybox[i],zbox[i]) of an axis aligned box knowing */
@@ -10930,7 +5877,7 @@ void sciAxesVerticesIndices( integer insideU[4],
   
   if (ind < 0 || ind > 8) 
   {
-    Scistring("xind out of bounds");
+    sciprint("xind out of bounds");
     xind[0]=0;
   }
   Nextind(xind[0],&ind2,&ind3);
@@ -11068,92 +6015,5 @@ void computeLabelAutoPos( sciPointObj * pLabel, int axisStart[2], int axisEnd[2]
 
 }
 /*------------------------------------------------------------------------------------------*/
-/**
- * draw the marks at the vertices of a polyline.
- * @param[in] pObj Object on which the marks will be drawn. Might be a polyline, a segs or
- *                 rectangle object.
- * @param[in] nbMarks Number of marks to draw.
- * @param[in] xCoord X coordinates of the marks in pixels.
- * @param[in] yCoord Y coordinates of the marks in pixels.
- * @param     DPI    ???
- */
-void drawPolyMarks( sciPointObj * pObj, int nbMarks, int xCoord[], int yCoord[], int * DPI )
-{
-  int foreground = sciGetMarkForeground( pObj ) ;
-  int v     = 0   ;
-  double dv = 0.0 ;
-  int markIdSize[2] ;
-
-  markIdSize[0] = sciGetMarkStyle( pObj ) ;
-  markIdSize[1] = sciGetMarkSize(  pObj ) ;
-
-  C2F (dr) ("xset", "dashes", &foreground, &foreground, &v, &v, &v, &v, &dv,
-    &dv, &dv, &dv, 5L, 4096);     
-  C2F (dr) ("xset", "foreground", &foreground, &foreground, &v, &v, &v, &v,
-    &dv, &dv, &dv, &dv, 5L, 4096);
-
-  C2F (dr) ("xset", "mark", &markIdSize[0], &markIdSize[1], PI0, PI0, PI0, PI0, PD0, PD0,
-    PD0, PD0, 0L, 0L);
-
-  DrawNewMarks( pObj, nbMarks, xCoord, yCoord, DPI ) ;
-}
-/*------------------------------------------------------------------------------------------*/
-/**
-* Compute the arrow size which must be used in (dr)(xarrows).
-* @param[in] pSegs object of which we are displaying arrows.
-* @param[in] X coordinates in pixels of the segments
-* @param[in] Y coordinates in pixels of the segments
-* @return    Size to use in xarrows.
-*/
-int computeRealArrowSize( sciPointObj * pSegs, int nbSegs, int xCoord[], int yCoord[] )
-{
-  sciSegs * ppSegs = pSEGS_FEATURE( pSegs ) ;
-  double arrowSize = ppSegs->arrowsize ;
-  int one = 1 ;
-
-  if ( ppSegs->ptype == 0 )
-  {
-    if ( arrowSize > 0 )
-    {
-      int iAs2 = 0 ;
-      int iAs  = 0 ;
-      C2F(echelle2dl)( &arrowSize, &arrowSize, &iAs, &iAs2, &one, &one, "f2i" ) ;
-      return iAs / 2 ;
-    }
-    else
-    {
-      /* taken from Xcall1.c */
-      int i ;
-      double length = 0.0 ;
-      for ( i = 0 ; i < nbSegs / 2 ; i++ )
-      {
-        double dx ;
-        double dy ;
-        dx=( xCoord[2*i+1] - xCoord[2*i] ) ;
-        dy=( yCoord[2*i+1] - yCoord[2*i] ) ;
-        length += sqrt( dx * dx + dy * dy ) ;
-      }
-      if ( nbSegs != 0 )
-      {
-        length /= nbSegs / 2 ;
-      }
-      return round( -arrowSize * length ) ;
-    }
-  }
-  else
-  {
-    if ( ppSegs->arrowsize >= 0 )
-    {
-      double arsize1 = ((double) Cscale.WIRect1[2])/(5*( ppSegs->Nbr1));
-      double arsize2 = ((double) Cscale.WIRect1[3])/(5*( ppSegs->Nbr2));
-      double arsize  =  (arsize1 < arsize2) ? inint(arsize1*10.0) : inint(arsize2*10.0) ;
-      return (int)((arsize)*(ppSegs->arrowsize));
-    }
-  }
-
-  return 0 ;
-
-}
-/*------------------------------------------------------------------------------------------*/
 
 #undef round
index a84b283..88c3c31 100644 (file)
@@ -1,11 +1,13 @@
 /*------------------------------------------------------------------------
  *    Graphic library
- *    Copyright (C) 1998-2001 Enpc/Jean-Philippe Chancelier
- *    jpc@cermics.enpc.fr 
+ *    Copyright (C) 1998-2001 Enpc
+ *    Copyright INRIA 2006
+ *    Jean-Philippe Chancelier - jpc@cermics.enpc.fr
+ *    Jean-Baptiste Silvy
  *
  *    modified by Bruno Pincon 01/02/2001 for gain in speed and added 
  *    possibilities to set zmin, zmax by the user and also to set the 
- *    first and last color of the colormap (Bruno.Pincon@iecn.u-nancy.fr)
+ *    first and last color of the colormap (Bruno.Pincon@iecn.u-nancy.fr
  *
 for entities handling
  --------------------------------------------------------------------------*/
@@ -22,6 +24,8 @@ for entities handling
 #include "BuildObjects.h"
 #include "DrawObjects.h"
 #include "Xcall1.h"
+#include "MALLOC.h"
+#include "sciprint.h"
 
 extern int version_flag(void); /* NG */
 
@@ -344,14 +348,14 @@ void newfec(integer *xm,integer *ym,double *triangles,double *func,integer *Nnod
  
   /* allocations for some arrays ... */
   nz = color_max - color_min + 1;
-  zone = graphic_alloc(2,(*Nnode),sizeof(int));
-  zlevel = graphic_alloc(3,nz+1,sizeof(double));
-  fill  = graphic_alloc(4,nz+2,sizeof(int));
+  zone   = MALLOC( *Nnode * sizeof(int)    ) ; /*graphic_alloc(2,(*Nnode),sizeof(int)); */
+  zlevel = MALLOC( (nz+1) * sizeof(double) ) ;/* graphic_alloc(3,nz+1,sizeof(double));*/
+  fill   = MALLOC( (nz+2) * sizeof(int)    ) ; /*graphic_alloc(4,nz+2,sizeof(int));*/
   if ( (zone == NULL) || (zlevel == NULL) || (fill  == NULL)) 
-    {
-      Scistring("fec: malloc No more Place\n");
-      return;
-    }
+  {
+    sciprint("fec: malloc No more Place\n");
+    return;
+  }
 
   /* compute the fill array (fill = - num color) */
   fill[0] = -col_under_min;
@@ -433,6 +437,11 @@ void newfec(integer *xm,integer *ym,double *triangles,double *func,integer *Nnod
       }
     }
 
+  FREE( zone   ) ;
+  FREE( zlevel ) ;
+  FREE( fill   ) ;
+
+
   frame_clip_off();
 }
 
diff --git a/scilab/modules/graphics/src/c/Fec.h b/scilab/modules/graphics/src/c/Fec.h
new file mode 100644 (file)
index 0000000..b17e8e8
--- /dev/null
@@ -0,0 +1,14 @@
+/*------------------------------------------------------------------------*/
+/* file: Fec.h                                                            */
+/* Copyright INRIA 2006                                                   */
+/* Authors : Jean-Baptiste Silvy                                          */
+/* desc : Functions used to draw fec objects                              */
+/*------------------------------------------------------------------------*/
+
+#ifndef _FEC_H_
+#define _FEC_H_
+
+void newfec(integer *xm,integer *ym,double *triangles,double *func,integer *Nnode,
+            integer *Ntr,double *zminmax,integer *colminmax, integer *colout, BOOL with_mesh) ;
+
+#endif /* _FEC_H_ */
index f8680cc..483e1f7 100644 (file)
@@ -5234,7 +5234,7 @@ int sciGetHiddenColor( sciPointObj * pObj )
 /**
  * return if an object can be added to a merge object and then can be sorted for correct
  * drawing.
- * Normaly, each object shoul dbe mergeable. But it needs some development.
+ * Normaly, each object should be mergeable. But it needs some development.
  */
 BOOL sciIsMergeable( sciPointObj * pObj )
 {
diff --git a/scilab/modules/graphics/src/c/GraphicZoom.c b/scilab/modules/graphics/src/c/GraphicZoom.c
new file mode 100644 (file)
index 0000000..d3fc104
--- /dev/null
@@ -0,0 +1,24 @@
+/*------------------------------------------------------------------------*/
+/* file: GraphicZoom.c                                                    */
+/* Copyright INRIA 2006                                                   */
+/* Authors : Jean-Baptiste Silvy                                          */
+/* desc : Contains functions to Zoom in the graphic window                */
+/*------------------------------------------------------------------------*/
+
+#include "GraphicZoom.h"
+
+/**
+ * To know if the zoom is activated
+ */
+static BOOL GlobalFlag_Zoom3dOn = FALSE ;
+/*----------------------------------------------------------------------------------------------*/
+BOOL isZoom3dOn( void )
+{
+  return GlobalFlag_Zoom3dOn ;
+}
+/*----------------------------------------------------------------------------------------------*/
+void setZoom3dStatus( BOOL status )
+{
+  GlobalFlag_Zoom3dOn = status ;
+}
+/*----------------------------------------------------------------------------------------------*/
diff --git a/scilab/modules/graphics/src/c/GraphicZoom.h b/scilab/modules/graphics/src/c/GraphicZoom.h
new file mode 100644 (file)
index 0000000..5684955
--- /dev/null
@@ -0,0 +1,20 @@
+/*------------------------------------------------------------------------*/
+/* file: GraphicZoom.h                                                    */
+/* Copyright INRIA 2006                                                   */
+/* Authors : Jean-Baptiste Silvy                                          */
+/* desc : Contains functions to Zoom in the graphic window                */
+/*------------------------------------------------------------------------*/
+
+
+#ifndef _GRAPHIC_ZOOM_H_
+#define _GRAPHIC_ZOOM_H_
+
+#include "ObjectStructure.h"
+
+/*-------------------------------------------------------------------------------------------*/
+BOOL isZoom3dOn( void ) ;
+void setZoom3dStatus( BOOL status ) ;
+/*-------------------------------------------------------------------------------------------*/
+
+
+#endif /* _GRAPHIC_ZOOM_H_ */
index 6ec9650..633f984 100644 (file)
@@ -19,6 +19,8 @@
 #include "BuildObjects.h"
 #include "Axes.h"
 #include "Xcall1.h"
+#include "Gray.h"
+#include "sciprint.h"
 
 
 #include "MALLOC.h" /* MALLOC */
@@ -457,7 +459,7 @@ int C2F(xgray2)(double *z, integer *n1, integer *n2, double *xrect)
     xm = graphic_alloc(0,(*n2)+1,sizeof(int));
     ym = graphic_alloc(1,(*n1)+1,sizeof(int));
     if ( xm == 0 || ym == 0 ) {
-      Scistring("Xgray: running out of memory\n");return 0;}
+      sciprint("Xgray: running out of memory\n");return 0;}
     frame_clip_on();
     for ( j =0 ; j < (*n2+1) ; j++)     
       xm[j]= (int) (( xx1[1]*j + xx1[0]*((*n2)-j) )/((double) *n2));
@@ -503,7 +505,7 @@ static void GraySquare1_base(integer *x, integer *y, double *z, integer n1, inte
   C2F(dr)("xset","pattern",&cpat,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
 }
 
-extern void GraySquare1(integer *x, integer *y, double *z, integer n1, integer n2)
+void GraySquare1(integer *x, integer *y, double *z, integer n1, integer n2)
 {
  
   if ( GetDriverId() == 0 ) 
@@ -518,7 +520,7 @@ extern void GraySquare1(integer *x, integer *y, double *z, integer n1, integer n
 /* Only for new graphics */
 /* NG: New Graphics */
 /* reverse means reverse case on X and/or Y axis */
-extern void GraySquare1_NGreverse(integer * x, integer *y, double *z, integer n1, integer n2, sciPointObj * psubwin)
+void GraySquare1_NGreverse(integer * x, integer *y, double *z, integer n1, integer n2, sciPointObj * psubwin)
 {
   int i,j;
   integer verbose=0,narg,fill[1],cpat,xz[2];
@@ -566,16 +568,7 @@ extern void GraySquare1_NGreverse(integer * x, integer *y, double *z, integer n1
   
 }
 
-
-
-
-
-
-
-
-
-
-extern void GraySquareDirect(integer *x, integer *y, double *z, integer n1, integer n2)
+void GraySquareDirect(integer *x, integer *y, double *z, integer n1, integer n2)
 {
   integer i,j,verbose=0,whiteid,narg,fill,cpat,xz[2];
   integer vertexx[5], vertexy[5];
diff --git a/scilab/modules/graphics/src/c/Gray.h b/scilab/modules/graphics/src/c/Gray.h
new file mode 100644 (file)
index 0000000..f04e362
--- /dev/null
@@ -0,0 +1,22 @@
+/*------------------------------------------------------------------------
+ *    Graphic library
+ *    Copyright (C) 1998-2001 Enpc/Jean-Philippe Chancelier
+ *    jpc@cermics.enpc.fr
+ *    Copyright INRIA 2006
+ *    Jean-Baptiste Silvy
+ *
+ *    Modified 2002 Djalel Abdemouche INRIA for entity mode (NG)
+ --------------------------------------------------------------------------*/
+
+#ifndef _GRAY_H_
+#define _GRAY_H_
+
+void GraySquareDirect(integer *x, integer *y, double *z, integer n1, integer n2) ;
+
+void GraySquareScaled(integer *x, integer *y, double *z, integer n1, integer n2) ;
+
+void GraySquare1(integer *x, integer *y, double *z, integer n1, integer n2) ;
+
+void GraySquare1_NGreverse(integer * x, integer *y, double *z, integer n1, integer n2, sciPointObj * psubwin) ;
+
+#endif /* _GRAY_H_ */
index 15dc931..97039ca 100644 (file)
@@ -12,6 +12,7 @@
 #include "PloEch.h"
 #include "Plo2d.h"
 #include "Xcall1.h"
+#include "sciprint.h"
 
 #define spINSIDE_SPARSE
 #include "../../sparse/includes/spConfig.h"
@@ -281,7 +282,7 @@ void update_frame_bounds(cflag, xf, x, y, n1, n2, aaint, strflag, FRect)
        }
       else
        {
-         Scistring("Warning: Can't use Log on X-axis xmin is negative \n");
+         sciprint("Warning: Can't use Log on X-axis xmin is negative \n");
          xmax= 1; xmin= 0;
        }
       aaint[0]=1;aaint[1]=inint(xmax-xmin);
@@ -297,7 +298,7 @@ void update_frame_bounds(cflag, xf, x, y, n1, n2, aaint, strflag, FRect)
        }
       else
        {
-         Scistring(" Can't use Log on y-axis ymin is negative \n");
+         sciprint(" Can't use Log on y-axis ymin is negative \n");
          ymax= 1; ymin= 0;
        }
       aaint[2]=1;aaint[3]=inint(ymax-ymin);
@@ -320,7 +321,7 @@ void update_frame_bounds(cflag, xf, x, y, n1, n2, aaint, strflag, FRect)
               || (ylog == 1 && Cscale.logflag[1] == 'n')
               || (ylog == 0 && Cscale.logflag[1] == 'l') )
            {
-             Scistring("Warning: you cannot use automatic rescale if you switch from log to normal or normal to log \n");
+             sciprint("Warning: you cannot use automatic rescale if you switch from log to normal or normal to log \n");
            }
          else 
            { 
@@ -390,7 +391,7 @@ void update_frame_bounds(cflag, xf, x, y, n1, n2, aaint, strflag, FRect)
       GetDriver1(driver,PI0,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
       if (strcmp("Rec",driver) != 0) 
        {
-         Scistring("Auto rescale only works with the rec driver\n");
+         sciprint("Auto rescale only works with the rec driver\n");
          return;
        }
       C2F(dr1)("xget","window",&verbose,&ww,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
@@ -410,12 +411,11 @@ void update_frame_bounds(cflag, xf, x, y, n1, n2, aaint, strflag, FRect)
  *-----------------------------------------------------*/
 
 
-void Legends(style, n1, legend)
-     integer *style;
-     integer *n1;
-     char *legend;
+void Legends( integer * style, integer * n1, char * legend )
 {
-  int rect[4],xx,yy;
+  int rect[4] ;
+  int xx = 0  ;
+  int yy = 0  ;
   char *leg,*loc;
   double xi,xi1,yi,yi1,xoffset,yoffset;  
   int i;
@@ -499,7 +499,7 @@ void Legends(style, n1, legend)
     }
   else
     {
-      Scistring("Legends : running out of memory to store legends\n");
+      sciprint("Legends : running out of memory to store legends\n");
     }
 }
 
index 8e699eb..c360ed1 100644 (file)
@@ -11,8 +11,7 @@
 #include "Graphics.h" 
 #include "PloEch.h"
 #include "Xcall1.h"
-
-extern void Plo2d2RealToPixel __PARAMS((integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf));
+#include "Plo2d1.h"
 
 /*--------------------------------------------------------------------
   C2F(plot2d2)(xf,x,y,n1,n2,style,strflag,legend,brect,aint)
@@ -67,7 +66,7 @@ int C2F(plot2d2)(char *xf, double *x, double *y, integer *n1, integer *n2, integ
 }
 
 
-extern void Plo2d2RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf)
+void Plo2d2RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf)
 {
   integer i,j;
   /** Computing y-values **/
index e684830..e0cddf1 100644 (file)
 #include "math_graphics.h"
 #include "Graphics.h" 
 #include "PloEch.h"
-
+#include "Plo2d1.h"
 #include "GetProperty.h"
 #include "Xcall1.h"
 
-extern void Plo2d3RealToPixel __PARAMS((integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf));
 
 /*--------------------------------------------------------------------
   C2F(plot2d3)(xf,x,y,n1,n2,style,strflag,legend,brect,aaint)
@@ -81,7 +80,7 @@ int C2F(plot2d3)(char *xf, double *x, double *y, integer *n1, integer *n2, integ
 }
 
 
-extern void Plo2d3RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf)
+void Plo2d3RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf)
 {
   integer i,j;
   /** Computing y-values **/
index 7450b43..dfed8a0 100644 (file)
@@ -11,8 +11,8 @@
 #include "Graphics.h" 
 #include "PloEch.h"
 #include "Xcall1.h"
+#include "Plo2d1.h"
 
-extern void Plo2d4RealToPixel __PARAMS((integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf));
 /*--------------------------------------------------------------------
   C2F(plot2d4)(xf,x,y,n1,n2,style,strflag,legend,brect,aaint)
 --------------------------------------------------------------------------*/
@@ -79,7 +79,7 @@ int C2F(plot2d4)(char *xf, double *x, double *y, integer *n1, integer *n2, integ
 
 
 
-extern void Plo2d4RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf)
+void Plo2d4RealToPixel(integer *n1, integer *n2, double *x, double *y, integer *xm, integer *ym, char *xf)
 {
   integer i,j;
   /** Computing y-values **/
index 3f21f14..58a1a14 100644 (file)
 #include "DrawObjects.h"
 #include "Xcall1.h"
 #include "Plo2dEch.h"
+#include "Vertices.h"
+#include "GraphicZoom.h"
+#include "axesScale.h"
 
 #include "MALLOC.h" /* MALLOC */
 
-int GlobalFlag_Zoom3dOn=0;
-int index_vertex=0;
+//int index_vertex=0;
 /* static double xz1,yz1; */
 /* #define pixel2TRX(x) xz1= Cscale.frect[0] + (1.0/Cscale.Wscx1)*((x) - Cscale.Wxofset1) */
 /* #define pixel2TRY(y) yz1= Cscale.frect[3] - (1.0/Cscale.Wscy1)*((y) - Cscale.Wyofset1) */
@@ -186,7 +188,7 @@ static void set_scale_win(listptr, i,scale)
       /* window i does not exist add an entry for it */
       if ((*listptr = (ScaleList *) MALLOC( sizeof (ScaleList)))==0)
        {
-         Scistring("AddWindowScale_ memory exhausted\n");
+         sciprint("AddWindowScale_ memory exhausted\n");
          return;
        }
       else 
@@ -197,7 +199,7 @@ static void set_scale_win(listptr, i,scale)
          if ( (*listptr)->scales == 0) 
            {
              *listptr = 0;
-             Scistring("AddWindowScale_ memory exhausted\n");
+