periFig.c

Go to the documentation of this file.

/*------------------------------------------------------------------------
 *    Graphic library
 *    Copyright (C) 1998-2001 Enpc/Jean-Philippe Chancelier
 *    jpc@cermics.enpc.fr 
 --------------------------------------------------------------------------*/

/*----------------------BEGIN----------------------
\def\encadre#1{\paragraph{}\fbox{\begin{minipage}[t]{15cm}#1 \end{minipage}}}
\section{A Fig Driver}
---------------------------------------------------*/

#include <stdio.h>
#include <math.h>
#include <string.h>

#ifdef __STDC__
#include <stdlib.h>
#endif

#include "machine.h"


#if defined(_MSC_VER)
#define CoordModePrevious 1
#define CoordModeOrigin 0
#define GXclear 0
#define GXand 1
#define GXandReverse 2
#define GXcopy 3
#define GXandInverted 4
#define GXnoop 5
#define GXxor 6
#define GXor 7
#define GXnor 8
#define GXequiv 9
#define GXinvert 10
#define GXorReverse 11
#define GXcopyInverted 12
#define GXorInverted 13
#define GXnand 14
#define GXset 15
#endif

#include "math_graphics.h"
#include "periFig.h"
#include "color.h"
#include "bcg.h" /* NG */
#include "clipping.h"
#include "sciprint.h"
#include "periScreen.h"


#include "MALLOC.h" /* MALLOC */

struct BCG  ScilabGCXfig ;

static BOOL ScilabGCXfig_is_initialized = FALSE;

#define WHITE 7
#define BLACK 0

void C2F(Write2VectXfig)(integer *vx, integer *vy, integer n, integer flag); 
void C2F(WriteGenericXfig)(char *string, integer nobj, integer sizeobj, integer *vx, integer *vy, integer sizev, integer flag, integer *fvect);
void C2F(InitScilabGCXfig)(integer *v1, integer *v2, integer *v3, integer *v4);
void C2F(setforegroundXfig)(integer *num, integer *v2, integer *v3, integer *v4);
void C2F(ScilabGCGetorSetXfig)(char *str, integer flag, integer *verbose, integer *x1, integer *x2, integer *x3, integer *x4, integer *x5, integer *x6, double *dx1);
void C2F(setbackgroundXfig)(integer *num, integer *v2, integer *v3, integer *v4);
void C2F(set_cXfig)(integer i);
void C2F(idfromnameXfig) (char *name1, integer *num);
void C2F(getdashXfig)(integer *verbose, integer *value, integer *narg, double *dummy);

/* NG beg */
void C2F(setscilabFigureXfig)(integer *v1,integer *v2,integer *v3,integer *v4,integer *v5,integer *v6,double *figure);
void C2F(getscilabFigureXfig)(integer *verbose, integer *x,integer *narg, double *figure);
void C2F(setscilabVersionXfig)(integer *vers, integer *v2, integer *v3, integer *v4);
void C2F(getscilabVersionXfig)(integer *verbose, integer *vers, integer *narg, double *dummy);
void C2F(setscilabxgcXfig)(integer *v1, integer *v2, integer *v3, integer *v4); 
void C2F(getscilabxgcXfig)(integer *verbose, integer *x,integer *narg, double *dummy);
/* NG end */

extern void getcolordef( integer * screenc ) ;
extern void setcolordef( integer   screenc ) ;

static void 
C2F(analyze_pointsXfig) (integer n, integer *vx, integer *vy,
                         integer onemore);

static void C2F(displaysymbolsXfig) (char *str, integer *n, integer *vx, integer *vy);
static int C2F(FigQueryFont)(char *name);
static void set_dash_or_color (int dash,int *l_style,int *style_val,int *color);

#define Char2Int(x)   ( x & 0x000000ff )
static double *vdouble = 0; /* used when a double argument is needed */
#define FONTNUMBER 11
#define FONTMAXSIZE 6
#define SYMBOLNUMBER 10
integer FontsListXfig_[FONTNUMBER][FONTMAXSIZE];
struct SciFontInfo { integer ok;
                  char fname[21];} FontInfoTabXfig_[FONTNUMBER];
static integer  xfig_font[]= { 12,32,0,1,2,3,16,17,18,19,0};
static char *sizeXfig_[] = { "08" ,"10","12","14","18","24"};
static integer  isizeXfig_[] = { 8,10,12,14,18,24};

#if defined(__GNUC__) || defined(_MSC_VER)|| defined(__EDG__)
static FILE *file= (FILE *) 0;
#define FPRINTF(x) ( file != (FILE*) 0) ?  fprintf x  : 0 
#else 
static FILE *file= stdout ;
#define FPRINTF(x) fprintf x  
#endif

static void C2F(FileInitXfig) __PARAMS((void));
static void C2F(FileInitFromScreenXfig) __PARAMS((void));
static void set_dash  __PARAMS((int dash,int *l_style,int *_val));
static void set_color  __PARAMS((int c,int *color));


/*-----------------------------------------------------
\encadre{General routines}
-----------------------------------------------------*/

void C2F(xselgraphicXfig)(char *v1, integer *v2, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{}

void C2F(xendgraphicXfig)(void)
{
  if (file != stdout && file != (FILE*) 0) {
    fclose(file);
    file=stdout;
  }
  ScilabGCXfig_is_initialized = FALSE;
}

void C2F(xendXfig)(char *v1, integer *v2, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  C2F(xendgraphicXfig)();
}


void C2F(clearwindowXfig)(char *v1, integer *v2, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  /* F.Leray : I add a rectangle with  background color*/
  integer i = 1;
  int zero = 0, col;
  integer vects[4], narg;
  double dv;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  vects[0]= zero;
  vects[1]= zero;
  C2F(getwindowdimXfig)(&zero,&vects[2],&narg,&dv);

  col = ScilabGCXfig.NumBackground+1;
  
  C2F(drawrectanglesXfig)("",vects,&col,&i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);    
  
}

void C2F(viderbuffXfig)(void)
{}

static int prec_fact =16;

void C2F(getwindowdimXfig)(integer *verbose, integer *x, integer *narg, double *dummy)
{     
  *narg = 2;
  x[0]= 600*prec_fact;
  x[1]= 424*prec_fact;
  if (*verbose == 1) 
    sciprint("\n CWindow dim :%d,%d\r\n",(int)x[0],(int)x[1]);
} 

void C2F(setwindowdimXfig)(integer *x, integer *y, integer *v3, integer *v4)
{
}

void C2F(getwindowposXfig)(integer *verbose, integer *x, integer *narg, double *dummy)
{
  *narg = 2;
  x[0]= x[1]=0;
  if (*verbose == 1) 
    sciprint("\n CWindow position :%d,%d\r\n",(int)x[0],(int)x[1]);
 }

void C2F(setwindowposXfig)(integer *x, integer *y, integer *v3, integer *v4)
{
}


void C2F(xclickXfig)(char *str, integer *ibutton, integer *xx1, integer *yy1, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ }

void C2F(xclick_anyXfig)(char *str, integer *ibutton, integer *xx1, integer *yy1, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ }

void C2F(xgetmouseXfig)(char *str, integer *ibutton, integer *xx1, integer *yy1, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ }

void C2F(clearareaXfig)(char *str, integer *x, integer *y, integer *w, integer *h, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  FPRINTF((file,"# %d %d %d %d clearzone\n",(int)*x,(int)*y,(int)*w,(int)*h));
}

/*------------------------------------------------
\encadre{Functions to modify the graphic state}
-------------------------------------------------*/

void C2F(setcurwinXfig)(integer *intnum, integer *v2, integer *v3, integer *v4)
{
  ScilabGCXfig.CurWindow = *intnum;
}

void C2F(getcurwinXfig)(integer *verbose, integer *intnum, integer *narg, double *dummy)
{
  *narg =1 ;
  *intnum = ScilabGCXfig.CurWindow ;
  if (*verbose == 1) 
    sciprint("\nJust one graphic page at a time ");
}

void C2F(setclipXfig)(integer *x, integer *y, integer *w, integer *h)
{
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  ScilabGCXfig.ClipRegionSet = 1;
  ScilabGCXfig.CurClipRegion[0]= *x;
  ScilabGCXfig.CurClipRegion[1]= *y;
  ScilabGCXfig.CurClipRegion[2]= *w;
  ScilabGCXfig.CurClipRegion[3]= *h;
  FPRINTF((file,"# %d %d %d %d setclipzone\n",(int)*x,(int)*y,(int)*w,(int)*h));
}


void C2F(unsetclipXfig)(integer *v1, integer *v2, integer *v3, integer *v4)
{
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  ScilabGCXfig.ClipRegionSet = 0;
  ScilabGCXfig.CurClipRegion[0]= -1;
  ScilabGCXfig.CurClipRegion[1]= -1;
  ScilabGCXfig.CurClipRegion[2]= 200000;
  ScilabGCXfig.CurClipRegion[3]= 200000;
  FPRINTF((file,"# %d %d %d %d setclipzone\n",-1,-1,200000,200000));
}

void C2F(getclipXfig)(integer *verbose, integer *x, integer *narg, double *dummy)
{
  x[0] = ScilabGCXfig.ClipRegionSet;
  if ( x[0] == 1)
    {
      *narg = 5;
      x[1] =ScilabGCXfig.CurClipRegion[0];
      x[2] =ScilabGCXfig.CurClipRegion[1];
      x[3] =ScilabGCXfig.CurClipRegion[2];
      x[4] =ScilabGCXfig.CurClipRegion[3];
    }
  else *narg = 1;
  if (*verbose == 1)
    {
      if (ScilabGCXfig.ClipRegionSet == 1)
        sciprint("\nThere's a Clip Region :x:%d,y:%d,w:%d,h:%d\r\n",
                 ScilabGCXfig.CurClipRegion[0],
                 ScilabGCXfig.CurClipRegion[1],
                 ScilabGCXfig.CurClipRegion[2],
                 ScilabGCXfig.CurClipRegion[3]);
      else 
        sciprint("\nNo Clip Region");
    }
}

/*----------------------------------------------------------
\encadre{For the drawing functions dealing with vectors of 
 points, the following routine is used to select the mode 
 absolute or relative }
 Absolute mode if *num==0, relative mode if *num != 0
------------------------------------------------------------*/

void C2F(absourelXfig)(integer *num, integer *v2, integer *v3, integer *v4)
{
  if (*num == 0 )
    ScilabGCXfig.CurVectorStyle =  CoordModeOrigin;
  else 
    ScilabGCXfig.CurVectorStyle =  CoordModePrevious ;
}

void C2F(getabsourelXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{
  *narg = 1;
  *num = ScilabGCXfig.CurVectorStyle  ;
  if (*verbose == 1) 
    {
      if (ScilabGCXfig.CurVectorStyle == CoordModeOrigin)
        sciprint("\nTrace Absolu");
      else 
        sciprint("\nTrace Relatif");
    }
}


void C2F(setalufunctionXfig)(char *string)
{     
  integer value;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(idfromnameXfig)(string,&value);
  if ( value != -1)
    {ScilabGCXfig.CurDrawFunction = value;
     FPRINTF((file,"# %d setalufunction\n",(int)value));
      }
}

struct alinfo { 
  char *name;
  char id;
  char *info;} AluStrucXfig_[] =
{ 
  {"GXclear" ,GXclear," 0 "},
  {"GXand" ,GXand," src AND dst "},
  {"GXandReverse" ,GXandReverse," src AND NOT dst "},
  {"GXcopy" ,GXcopy," src "},
  {"GXandInverted" ,GXandInverted," NOT src AND dst "},
  {"GXnoop" ,GXnoop," dst "},
  {"GXxor" ,GXxor," src XOR dst "},
  {"GXor" ,GXor," src OR dst "},
  {"GXnor" ,GXnor," NOT src AND NOT dst "},
  {"GXequiv" ,GXequiv," NOT src XOR dst "},
  {"GXinvert" ,GXinvert," NOT dst "},
  {"GXorReverse" ,GXorReverse," src OR NOT dst "},
  {"GXcopyInverted" ,GXcopyInverted," NOT src "},
  {"GXorInverted" ,GXorInverted," NOT src OR dst "},
  {"GXnand" ,GXnand," NOT src OR NOT dst "},
  {"GXset" ,GXset," 1 "}
};

void C2F(idfromnameXfig)(char *name1, integer *num)
{integer i;
 *num = -1;
 for ( i =0 ; i < 16;i++)
   if (strcmp(AluStrucXfig_[i].name,name1)== 0) 
     *num=AluStrucXfig_[i].id;
 if (*num == -1 ) 
   {
     sciprint("\n Use the following keys :");
     for ( i=0 ; i < 16 ; i++)
       {
         sciprint("\nkey %s ",AluStrucXfig_[i].name);
         sciprint("-> %s\r\n",AluStrucXfig_[i].info);
       }
   }
}


void C2F(setalufunction1Xfig)(integer *num, integer *v2, integer *v3, integer *v4)
{     
  integer value;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  value=AluStrucXfig_[Min(16,Max(0,*num))].id;
  if ( value != -1)
    {
      ScilabGCXfig.CurDrawFunction = value;
      /* to be done */
    }
}

void C2F(getalufunctionXfig)(integer *verbose, integer *value, integer *narg, double *dummy)
{ 
  *narg =1 ;
  *value = ScilabGCXfig.CurDrawFunction ;
   if (*verbose ==1 ) 
     { 
       sciprint("\nThe Alufunction is %s",AluStrucXfig_[*value].name);
       sciprint("-> <%s>\r\n", AluStrucXfig_[*value].info);
     }
}

void C2F(setthicknessXfig)(integer *value, integer *v2, integer *v3, integer *v4)
{ 
  ScilabGCXfig.CurLineWidth =Max(1, *value);
  FPRINTF((file,"# %d Thickness\n",(int)Max(1L,*value)));
}

void C2F(getthicknessXfig)(integer *verbose, integer *value, integer *narg, double *dummy)
{
  *narg =1 ;
  *value = ScilabGCXfig.CurLineWidth ;
  if (*verbose ==1 ) 
    sciprint("\nLine Width:%d\r\n", ScilabGCXfig.CurLineWidth ) ;
}
     
/*-------------------------------------------------
\encadre{To set grey level for filing areas.
  from black (*num =0 ) to white 
  you must use the get function to get the id of 
  the white pattern }
----------------------------------------------------*/

void C2F(setpatternXfig)(integer *num, integer *v2, integer *v3, integer *v4)
{ integer i ; 
  if (  ScilabGCXfig.CurColorStatus ==1) 
    {
      i= Max(0,Min(*num-1,ScilabGCXfig.Numcolors+1));
      ScilabGCXfig.CurColor = i ;
      C2F(set_cXfig)(i);
    }
  else 
    {
      i= Max(0,Min(*num-1,GREYNUMBER-1));
      ScilabGCXfig.CurPattern = i;
      if (i ==0)
        FPRINTF((file,"# fillsolid\n"));
      else 
        FPRINTF((file,"# %d Setgray\n",(int)i));
    }
}

void C2F(getpatternXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{ 
  *narg=1;
  if ( ScilabGCXfig.CurColorStatus ==1) 
    {
      *num = ScilabGCXfig.CurColor+1 ;
      if (*verbose == 1) 
        sciprint("\n Color : %d\r\n",
                 ScilabGCXfig.CurPattern);
    }
  else 
    {
      *num = ScilabGCXfig.CurPattern +1;
      if (*verbose == 1) 
        sciprint("\n Pattern : %d\r\n",
                 ScilabGCXfig.CurPattern);
    }
}

void C2F(getlastXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{
  *num = ScilabGCXfig.IDLastPattern +1 ;
  if (*verbose==1)
    sciprint("\n Id of White Pattern %d\r\n",(int)*num);
  *narg=1;
}


#define MAXDASH 6

/* solid dash dotted dash-dot dash-dot-dot dash-dot-dot-dot   */
static integer DashTab[MAXDASH]      = {0,1,1,2,2,2} ;
static integer DashTabStyle[MAXDASH] = {0,2,4,2,4,8} ;


/* old version of setdashXfig retained for compatibility */

void C2F(set_dash_or_color_Xfig)(integer *value, integer *v2, integer *v3, integer *v4)
{
  integer maxdash = MAXDASH ;
  integer l3 ;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  if ( ScilabGCXfig.CurColorStatus ==1) 
    {
      int i;
      i= Max(0,Min(*value-1,ScilabGCXfig.Numcolors+1));
      ScilabGCXfig.CurColor =i;
      C2F(set_cXfig)(i);
    }
  else
    {
      l3 = Max(0,Min(maxdash-1,(*value)-1));
      ScilabGCXfig.CurDashStyle = l3;
    }
}

void C2F(setdashXfig)(integer *value, integer *v2, integer *v3, integer *v4)
{
  integer maxdash = MAXDASH ;
  integer l3 ;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  l3 = Max(0,Min(maxdash-1,(*value)-1));
  ScilabGCXfig.CurDashStyle = l3;
}

void C2F(set_dash_and_color_Xfig)(integer *value, integer *v2, integer *v3, integer *v4)
{
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(setdashXfig)(value, v2, v3, v4); 
  C2F(setpatternXfig)(value+6, v2, v3, v4);
}

/* style arguments sets either dash style either color */
void C2F(set_line_style_Xfig)(integer *value, integer *v2, integer *v3, integer *v4)
{
  integer j; 

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  if (ScilabGCXfig.CurColorStatus == 0) {
    C2F(setdashXfig)(value,PI0,PI0,PI0);
    C2F(setpatternXfig)((j=1,&j),PI0,PI0,PI0);
  }
  else {
    j= ScilabGCXfig.CurDashStyle + 1;
    C2F(setdashXfig)(&j,PI0,PI0,PI0);
    C2F(setpatternXfig)(value,PI0,PI0,PI0);
  }
}

/* old version of getdashXfig retained for compatibility */

void C2F(get_dash_or_color_Xfig)(integer *verbose, integer *value, integer *narg, double *dummy)
{
  *narg =1 ;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  if ( ScilabGCXfig.CurColorStatus ==1) 
    {
      *value=ScilabGCXfig.CurColor + 1;
      if (*verbose == 1) sciprint("Color %d",(int)*value);
      return;
    }

  C2F(getdashXfig)(verbose, value+1, narg,dummy);
  *narg=*narg+1;
    
}

void C2F(getdashXfig)(integer *verbose, integer *value, integer *narg, double *dummy)
{
  integer i;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  i=ScilabGCXfig.CurDashStyle;

  *narg = 3;
  value[0]=i+1;
  value[1]=DashTab[i];
  value[2]=DashTabStyle[i];
  if (*verbose ==1 ) 
    {
      sciprint("\nDash Style %d.",(int) *value);
      sciprint("%d %d ",(int)value[1],(int)value[2]);
      sciprint(">\n");
    }
 
}
void C2F(get_dash_and_color_Xfig)(integer *verbose, integer *value, integer *narg, double *dummy)
{
  /*may be improved replacing 6 by narg */
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  C2F(getdashXfig)(verbose, value, narg,dummy);
  C2F(getpatternXfig)(verbose, value+6, narg,dummy);
  *narg = 6;
}


void C2F(usecolorXfig)(integer *num, integer *v2, integer *v3, integer *v4)
{
  integer i;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  i =  Min(Max(*num,0),1);
  if (  ScilabGCXfig.CurColorStatus != (int) i) 
    {
      if (ScilabGCXfig.CurColorStatus == 1) 
        {
          /* je passe de Couleur a n&b */
          /* remise des couleurs a vide */
          ScilabGCXfig.CurColorStatus = 1;
          C2F(setpatternXfig)((i=1,&i),PI0,PI0,PI0);
          /* passage en n&b */
          ScilabGCXfig.CurColorStatus = 0;
          i= ScilabGCXfig.CurPattern+1;
          C2F(setpatternXfig)(&i,PI0,PI0,PI0);
          i= ScilabGCXfig.CurDashStyle+1;
          C2F(setdashXfig)(&i,PI0,PI0,PI0);
          ScilabGCXfig.IDLastPattern = GREYNUMBER - 1;
        }
      else 
        {
          /* je passe en couleur */
          /* remise a zero des patterns et dash */
          /* remise des couleurs a vide */
          ScilabGCXfig.CurColorStatus = 0;
          C2F(setpatternXfig)((i=1,&i),PI0,PI0,PI0);
          C2F(setdashXfig)((i=1,&i),PI0,PI0,PI0);
          /* passage en couleur  */
          ScilabGCXfig.CurColorStatus = 1;
          i= ScilabGCXfig.CurColor+1;
          C2F(setpatternXfig)(&i,PI0,PI0,PI0);
          ScilabGCXfig.IDLastPattern = ScilabGCXfig.Numcolors -1;
        }
    }
}


void C2F(getusecolorXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
 
  *num = ScilabGCXfig.CurColorStatus;

  if (*verbose == 1) 
    sciprint("\n Use color %d\r\n",(int)*num);
  *narg=1;
}


/*******************************************************
 * Setting the colormap
 * Attention :
 *   cette fonction n'est utilis'ee que si l''on est sous
 *   le peripherique Xfig et que l'on appelle
 *   explicitement xset("colormap",....)
 * ds le cas usuel comme cette fonction n'est pas
 * enregistree ds Rec.c elle ne doit pas etre appellee
 ******************************************************/
void setcolormapgXfig(struct  BCG *Xgc,integer *v1,integer *v2, double *a, integer *v3);/* NG */

void C2F(setgccolormapXfig)(struct BCG *Xgc,integer m, double *a, integer *v3)
{
  int i,mm;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
 
  sciprint("Warning : you will have to move the colors definition\n");
  sciprint(" at the top of the xfig file \n");

  /* Checking RGB values */
  for (i = 0; i < m; i++) {
    if (a[i] < 0 || a[i] > 1 || a[i+m] < 0 || a[i+m] > 1 ||
        a[i+2*m] < 0 || a[i+2*m]> 1) {
      sciprint("RGB values must be between 0 and 1\n");
      *v3 = 1;
      return;
    }
  }
  Xgc->Numcolors = m;
  Xgc->IDLastPattern = m - 1;
  Xgc->NumForeground = m;
  Xgc->NumBackground = m + 1;
  for ( i=0; i < m ; i++)
    {
      unsigned short ur,ug,ub;
      ur = (unsigned short) (255.0*a[i]);
      ug = (unsigned short) (255.0*a[i+m]);
      ub = (unsigned short) (255.0*a[i+2*m]);
      FPRINTF((file,"0 %d #%02x%02x%02x \n",32+i,ur,ug,ub));
    }
  FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m,0,0,0));
  FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m+1,255,255,255));
  C2F(usecolorXfig)((i=1,&i) ,PI0,PI0,PI0);
  C2F(setalufunction1Xfig)((i=3,&i),PI0,PI0,PI0);
  C2F(setpatternXfig)((i=Xgc->NumForeground+1,&i),PI0,PI0,PI0);  
  C2F(setforegroundXfig)((i=Xgc->NumForeground+1,&i),PI0,PI0,PI0);
  C2F(setbackgroundXfig)((i=Xgc->NumForeground+2,&i),PI0,PI0,PI0);


  /* -------------------------------------------------------- */
  /* store the colormap for the get command too */
  /* F.Leray 04.10.05 */
  FREE(Xgc->Red);
  FREE(Xgc->Green);
  FREE(Xgc->Blue);
  
  /* don't forget black and white */
  mm = m;
  if (!(Xgc->Red = (float *) MALLOC(mm*sizeof(float)))) {
    sciprint("XgcAllocColors: unable to alloc\n");
    return;
  }
  if (!(Xgc->Green = (float *) MALLOC(mm*sizeof(float)))) {
    sciprint("XgcAllocColors: unable to alloc\n");
    FREE(Xgc->Red);
    return;
  }
  if (!(Xgc->Blue = (float *) MALLOC(mm*sizeof(float)))) {
    sciprint("XgcAllocColors: unable to alloc\n");
    FREE(Xgc->Red);
    FREE(Xgc->Green);
    return;
  }
  
  for(i=0;i<m;i++){
    Xgc->Red[i] = (float)a[i];
    Xgc->Green[i] = (float)a[i+m];
    Xgc->Blue[i] = (float)a[i+2*m]; 
  }
  /* -------------------------------------------------------- */
    
}

void C2F(getcolormapsizeXfig)(integer *v1, integer *v2, integer *v3, double *val)
{
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    *v3 = 1;
    return;
  }

  *v2 = ScilabGCXfig.Numcolors;
}

/* F.Leray 22.11.05: get the current colormap */

void C2F(getcolormapXfig)(integer *v1, integer *v2, integer *v3, double *val)
{
  int m;
  int i;
  *v3 = 0;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    *v3 = 1;
    return;
  }
  
  
  m = ScilabGCXfig.Numcolors;

  for (i = 0; i < m; i++) {
    val[i] = (double)ScilabGCXfig.Red[i];
    val[i+m] = (double)ScilabGCXfig.Green[i];
    val[i+2*m] = (double)ScilabGCXfig.Blue[i];
  }
}


void C2F(setcolormapXfig)(integer *v1, integer *v2, integer *v3, integer *v4, integer *v5, integer *v6, double *a)
{
 
  int m;

  *v3 = 0;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    *v3 = 1;
    return;
  }
 
  sciprint("Warning : you will have to move the colors definition\n");
  sciprint(" at the top of the xfig file \n");
  if (*v2 != 3 ||  *v1 < 0) {
    sciprint("Colormap must be a m x 3 array \n");
    *v3 = 1;
    return;
  }
  m = *v1;
  C2F(setgccolormapXfig)(&ScilabGCXfig, m, a, v3);
}

/* add *v3 (OUT) to know if colormap allocation has succeeded: */
/* 0: succeed */
/* 1: failed */
/* NG beg*/
void setcolormapgXfig(struct  BCG *Xgc,integer *m,integer *v2, double *a, integer *v3) /* NG */
{

  C2F(setgccolormapXfig)(Xgc,*m, a, v3);
}

void C2F(set_cXfig)(integer i)
{
  integer j;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  j=Max(Min(i,ScilabGCXfig.Numcolors+1),0);
  ScilabGCXfig.CurColor=j;
  FPRINTF((file,"# %d Setcolor\n",(int)i));
}

void C2F(setbackgroundXfig)(integer *num, integer *v2, integer *v3, integer *v4)
{ 
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  if (ScilabGCXfig.CurColorStatus == 1) 
    {
      ScilabGCXfig.NumBackground = Max(0,Min(*num - 1,ScilabGCXfig.Numcolors+1));
    }
}

void C2F(getbackgroundXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{ 
  *narg=1;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  if ( ScilabGCXfig.CurColorStatus == 1 ) 
    {
      *num = ScilabGCXfig.NumBackground + 1;
    }
  else 
    {
      *num = 1;
    }
  if (*verbose == 1) 
    sciprint("\n Background : %d\r\n",*num);
}


void C2F(setforegroundXfig)(integer *num, integer *v2, integer *v3, integer *v4)
{ 
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  if (ScilabGCXfig.CurColorStatus == 1) 
    {
      ScilabGCXfig.NumForeground = Max(0,Min(*num - 1,ScilabGCXfig.Numcolors+1));
    }
}

void C2F(getforegroundXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{ 
  *narg=1;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if ( ScilabGCXfig.CurColorStatus == 1 ) 
    {
      *num = ScilabGCXfig.NumForeground + 1;
    }
  else 
    {
      *num = ScilabGCXfig.IDLastPattern + 1;
    }
  if (*verbose == 1) 
    sciprint("\n Foreground : %d\r\n",*num);
}

void C2F(sethidden3dXfig)(integer *num, integer *v2, integer *v3, integer *v4)
{ 
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if (ScilabGCXfig.CurColorStatus == 1) 
    {
      /* es: Max(0,... -> Max(-1,... */
      /* S Mottelet: Max(-1,... -> Max(-2,...  to take into account the value -1 */
      ScilabGCXfig.NumHidden3d = Max(-2,Min(*num - 1,ScilabGCXfig.Numcolors + 1));
    }
}

void C2F(gethidden3dXfig)(integer *verbose, integer *num, integer *narg, double *dummy)
{ 
  *narg=1;

 if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if ( ScilabGCXfig.CurColorStatus == 1 ) 
    {
      *num = ScilabGCXfig.NumHidden3d + 1;
    }
  else 
    {
      *num = 1; 
    }
  if (*verbose == 1) 
    sciprint("\n Hidden3d : %d\r\n",*num);
}



/* void C2F(xsetfontXfig)(integer *fontid, integer *fontsize, integer *v3, integer *v4) */
/* { integer i,fsiz; */
/*   i = Min(FONTNUMBER-1,Max(*fontid,0)); */
/*   fsiz = Min(FONTMAXSIZE-1,Max(*fontsize,0)); */
/*   if ( FontInfoTabXfig_[i].ok !=1 ) */
/*     sciprint("\n Sorry This Font is Not available\n"); */
/*   else  */
/*    { */
/*      ScilabGCXfig.FontId = i; */
/*      ScilabGCXfig.FontSize = fsiz; */
/*      FPRINTF((file,"#/%s findfont %d scalefont setfont\n", */
/*                   FontInfoTabXfig_[i].fname, */
/*           (int)isizeXfig_[fsiz]*prec_fact)); */
/*    } */
/* } */

void C2F(xsetfontXfig)(integer *fontid, integer *fontsize, integer *v3, integer *v4)
{ 
  integer i,fsiz;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  i = Min(FONTNUMBER-1,Max(*fontid,0));
  fsiz = Min(FONTMAXSIZE-1,Max(*fontsize,0));

  if ( FontInfoTabXfig_[i].ok !=1 )
    {
      /* currently this case occurs only when i=FONTNUMBER-1 */
      sciprint("\n Sorry This Font is Not available: use default font (Times)\n");
      i = 2;
    }
  ScilabGCXfig.FontId = i;
  ScilabGCXfig.FontSize = fsiz;
  FPRINTF((file,"#/%s findfont %d scalefont setfont\n",
           FontInfoTabXfig_[i].fname,
           (int)isizeXfig_[fsiz]*prec_fact));
}

void C2F(xgetfontXfig)(integer *verbose, integer *font, integer *nargs, double *dummy)
{
  *nargs=2;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  font[0]= ScilabGCXfig.FontId ;
  font[1] =ScilabGCXfig.FontSize ;
  if (*verbose == 1) 
    {
      sciprint("\nFontId : %d ",ScilabGCXfig.FontId );
      sciprint("--> %s at size",
             FontInfoTabXfig_[ScilabGCXfig.FontId].fname);
      sciprint("%s pts\r\n",sizeXfig_[ScilabGCXfig.FontSize]);
    }
}

void C2F(setcursymbolXfig)(integer *number, integer *size, integer *v3, integer *v4)
{ 
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  ScilabGCXfig.CurHardSymb =
    Max(Min(SYMBOLNUMBER-1,*number),0);
  ScilabGCXfig.CurHardSymbSize = 
    Max(Min(FONTMAXSIZE-1,*size),0);
;}

void C2F(getcursymbolXfig)(integer *verbose, integer *symb, integer *narg, double *dummy)
{
  *narg =2 ;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  symb[0] = ScilabGCXfig.CurHardSymb ;
  symb[1] = ScilabGCXfig.CurHardSymbSize ;
  if (*verbose == 1) 
  {
    sciprint("\nMark : %d",ScilabGCXfig.CurHardSymb);
    sciprint("at size %s pts\r\n",
          sizeXfig_[ScilabGCXfig.CurHardSymbSize]);
  }
}


/*--------------------------------------------------------
\encadre{general routines accessing the  set<> or get<>
 routines } 
-------------------------------------------------------*/

void C2F(semptyXfig)(integer *verbose, integer *v2, integer *v3, integer *v4)
{
  if ( *verbose ==1 ) sciprint("\n No operation ");
}

void C2F(gemptyXfig)(integer *verbose, integer *v2, integer *v3, double *dummy)
{
  if ( *verbose ==1 ) sciprint("\n No operation ");
}



#define NUMSETFONC 32 /* NG */

struct bgc { char *name ;
             void  (*setfonc )() ;
             void  (*getfonc )() ;}
  ScilabGCTabXfig_[] = {
   {"alufunction",C2F(setalufunction1Xfig),C2F(getalufunctionXfig)},
   {"background",C2F(setbackgroundXfig),C2F(getbackgroundXfig)},
   {"clipoff",C2F(unsetclipXfig),C2F(getclipXfig)},
   {"clipping",C2F(setclipXfig),C2F(getclipXfig)},
   {"cmap_size",C2F(semptyXfig),C2F(getcolormapsizeXfig)},
   {"color",C2F(setpatternXfig),C2F(getpatternXfig)},
   {"colormap",C2F(setcolormapXfig),C2F(getcolormapXfig)},
   {"dashes",C2F(set_dash_or_color_Xfig),C2F(set_dash_or_color_Xfig)},
   {"default",C2F(InitScilabGCXfig), C2F(gemptyXfig)},
   {"figure",C2F(setscilabFigureXfig),C2F(getscilabFigureXfig)},/* NG */
   {"font",C2F(xsetfontXfig),C2F(xgetfontXfig)},
   {"foreground",C2F(setforegroundXfig),C2F(getforegroundXfig)},
   {"gc",C2F(semptyXfig),C2F(getscilabxgcXfig)},/* NG */
   {"gccolormap",C2F(setgccolormapXfig),C2F(gemptyXfig)},/* NG */
   {"hidden3d",C2F(sethidden3dXfig),C2F(gethidden3dXfig)},
   {"lastpattern",C2F(semptyXfig),C2F(getlastXfig)},
   {"line mode",C2F(absourelXfig),C2F(getabsourelXfig)},
   {"line style",C2F(setdashXfig),C2F(getdashXfig)},
   {"mark",C2F(setcursymbolXfig),C2F(getcursymbolXfig)},
   {"pattern",C2F(setpatternXfig),C2F(getpatternXfig)},
   {"pixmap",C2F(semptyXfig),C2F(gemptyXfig)},
   {"thickness",C2F(setthicknessXfig),C2F(getthicknessXfig)},
   {"use color",C2F(usecolorXfig),C2F(getusecolorXfig)},
   {"viewport",C2F(semptyXfig),C2F(gemptyXfig)},
   {"wdim",C2F(setwindowdimXfig),C2F(getwindowdimXfig)},
   {"white",C2F(semptyXfig),C2F(getlastXfig)},
   {"window",C2F(setcurwinXfig),C2F(getcurwinXfig)},
   {"wpdim",C2F(semptyXfig),C2F(gemptyXfig)},
   {"wpos",C2F(setwindowposXfig),C2F(getwindowposXfig)},
   {"wresize",C2F(semptyXfig),C2F(gemptyXfig)},
   {"wshow",C2F(semptyXfig),C2F(gemptyXfig)},
   {"wwpc",C2F(semptyXfig),C2F(gemptyXfig)},
 };



#ifdef lint

/* pour forcer lint a verifier ca */

static
test(str,flag,verbose,x1,x2,x3,x4,x5)
     char str[];
     integer flag ;
     integer  *verbose,*x1,*x2,*x3,*x4,*x5;
{ 
  double *dv;
  C2F(setalufunction1Xfig)(x1,x2,x3,x4);C2F(getalufunctionXfig)(verbose,x1,x2,dv);
  C2F(setclipXfig)(x1,x2,x3,x4);C2F(getclipXfig)(verbose,x1,x2,dv);
  C2F(setdashXfig)(x1,x2,x3,x4);C2F(getdashXfig)(verbose,x1,x2,dv);
  ScilabGCXfig_is_initialized = TRUE; /* add the flag ScilabGCXfig_is_initialized to test if xinit has been called */
  C2F(InitScilabGCXfig)(x1,x2,x3,x4); C2F(gemptyXfig)(verbose,x1,x2,dv);
  C2F(xsetfontXfig)(x1,x2,x3,x4);C2F(xgetfontXfig)(verbose,x1,x2,dv);
  C2F(absourelXfig)(x1,x2,x3,x4);C2F(getabsourelXfig)(verbose,x1,x2,dv);
  C2F(setcursymbolXfig)(x1,x2,x3,x4);C2F(getcursymbolXfig)(verbose,x1,x2,dv);
  C2F(setpatternXfig)(x1,x2,x3,x4);C2F(getpatternXfig)(verbose,x1,x2,dv);
  C2F(setthicknessXfig)(x1,x2,x3,x4);C2F(getthicknessXfig)(verbose,x1,x2,dv);
  C2F(usecolorXfig)(x1,x2,x3,x4);C2F(gemptyXfig)(verbose,x1,x2,dv);
  C2F(setwindowdimXfig)(x1,x2,x3,x4);C2F(getwindowdimXfig)(verbose,x1,x2,dv);
  C2F(semptyXfig)(x1,x2,x3,x4);C2F(getlastXfig)(verbose,x1,x2,dv);
  C2F(setcurwinXfig)(x1,x2,x3,x4);C2F(getcurwinXfig)(verbose,x1,x2,dv);
  C2F(setwindowposXfig)(x1,x2,x3,x4);getwindowposXfig(verbose,x1,x2,dv);
  
}

#endif 


void C2F(scilabgcgetXfig)(char *str, integer *verbose, integer *x1, integer *x2, integer *x3, integer *x4, integer *x5, double *dx1, double *dx2, double *dx3, double *dx4)
{
  int x6=0;
  C2F(ScilabGCGetorSetXfig)(str,(integer)1L,verbose,x1,x2,x3,x4,x5,&x6,dx1);
}

void C2F(scilabgcsetXfig)(char *str, integer *x2, integer *x3, integer *x4, integer *x5, integer *x6, integer *x7, double *dx1, double *dx2, double *dx3, double *dx4)
{
 integer verbose ;
 verbose = 0 ;
 C2F(ScilabGCGetorSetXfig)(str,(integer)0L,&verbose,x2,x3,x4,x5,x6,x7,dx1);
}

void C2F(ScilabGCGetorSetXfig)(char *str, integer flag, integer *verbose, integer *x1, integer *x2, integer *x3, integer *x4, integer *x5, integer *x6, double *dx1)
{ integer i ;
  for (i=0; i < NUMSETFONC ; i++)
     {
       integer j;
       j = strcmp(str,ScilabGCTabXfig_[i].name);
       if ( j == 0 ) 
         { if (*verbose == 1)
             sciprint("\nGetting Info on %s\r\n",str);
           if (flag == 1)
             (ScilabGCTabXfig_[i].getfonc)(verbose,x1,x2,dx1);
           else 
             (ScilabGCTabXfig_[i].setfonc)(x1,x2,x3,x4,x5,x6,dx1);
           return;}
       else 
         { if ( j <= 0)
             {
               sciprint("\nUnknow Postscript operator <%s>\r\n",str);
               *x1=1;*x2=0;
               return;
             }
         }
     }
  sciprint("\n Unknow Postscript operator <%s>\r\n",str);
  *x1=1;*x2=0;
}

/*-----------------------------------------------------------
\encadre{Functions for drawing}
-----------------------------------------------------------*/



/*----------------------------------------------------
\encadre{display of a string
 at (x,y) position whith angle (alpha). Angles in degree
 positive when clockwise. If *flag ==1 a framed  box is added 
 around the string.}
-----------------------------------------------------*/

void C2F(displaystringXfig)(char *string, integer *x, integer *y, integer *v1, integer *flag, integer *v6, integer *v7, double *angle, double *dv2, double *dv3, double *dv4)
{    
  integer rect[4], font=-1,font_flag=2;
  integer verbose=0,Dnarg,Dvalue1[10];
  int pen_color;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(boundingboxXfig)(string,x,y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
  if (string[0]== '$') 
    {
      font=-1;
      font_flag=2;
    }
  else 
    {
      font =  xfig_font[ScilabGCXfig.FontId];
      font_flag= 4; 
    };
  C2F(getpatternXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
  

  C2F(getpatternXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
  set_color(Dvalue1[0],&pen_color);
  FPRINTF((file,"4 0 %d 0 0 %d %d %5.2f %d %5.2f %5.2f %d %d %s\\001\n",
          pen_color,
          (int)font,
          (int)isizeXfig_[ScilabGCXfig.FontSize],
          -(M_PI/180.0)*(*angle),
          (int)font_flag,
          (double) rect[3],
          (double) rect[2],
          (int)*x,
          (int)*y,
          string));
  if ( *flag == 1) 
    {
      rect[0]=rect[0]-4;rect[2]=rect[2]+6;
      C2F(drawrectangleXfig)(string,rect,rect+1,rect+2,rect+3,PI0,PI0,PD0,PD0,PD0,PD0);
    }
}

integer bsizeXfig_[6][4]= {{ 0, -7,  463, 9  },
                           { 0, -9,  574, 12 },
                           { 0, -11, 674, 14 },
                           { 0, -12, 779, 15 },
                           { 0, -15, 972, 19 },
                           { 0, -20,1341, 26 }};

void C2F(boundingboxXfig)(char *string, integer *x, integer *y, integer *rect, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{integer verbose,nargs,font[2];
 verbose=0;

 C2F(xgetfontXfig)(&verbose,font,&nargs,vdouble);
 rect[0]= (int)(*x+bsizeXfig_[font[1]][0]*((double) prec_fact));
 rect[1]= (int)(*y+bsizeXfig_[font[1]][1]*((double) prec_fact));
 rect[2]= (int)(((double)prec_fact)*(bsizeXfig_[font[1]][2]/100.0)*((double)strlen(string)));
 rect[3]= (int)(bsizeXfig_[font[1]][3]*((double) prec_fact));
}

int symb_xw[FONTMAXSIZE][SYMBOLNUMBER]={
  {15,75,60,90,90,90,90,90,90,90},
  {30,75,75,105,75,105,105,105,75,105},
  {15,75,75,135,90,135,135,135,105,135},
  {30,105,105,135,105,165,150,165,120,150},
  {30,120,135,195,135,210,195,195,135,195},
  {45,150,150,255,195,270,255,270,195,255}
};

int symb_yh[FONTMAXSIZE][SYMBOLNUMBER]={
  {30,75,75,90,90,90,90,90,90,90},
  {30,90,90,120,105,105,105,105,105,105},
  {45,105,105,150,90,110,120,135,110,135},
  {45,120,120,150,105,165,135,160,125,150},
  {60,150,150,210,135,195,165,195,165,195},
  {90,180,195,270,180,270,230,270,195,270}
};


void C2F(boundingboxXfigM)(char *string, integer *x, integer *y, integer *rect, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  integer verbose,nargs,font[2];
  verbose=0;
  C2F(xgetfontXfig)(&verbose,font,&nargs,vdouble);
  rect[0]= (int)(*x+bsizeXfig_[font[1]][0]*((double) prec_fact));
  rect[1]= (int)(*y+bsizeXfig_[font[1]][1]*((double) prec_fact));
  rect[2]= (int)(symb_xw[ScilabGCXfig.CurHardSymbSize][ScilabGCXfig.CurHardSymb]);
  rect[3]= (int)(symb_yh[ScilabGCXfig.CurHardSymbSize][ScilabGCXfig.CurHardSymb]);
}



void C2F(drawlineXfig)(integer *x1, integer *yy1, integer *x2, integer *y2)
{  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  FPRINTF((file,"# %d %d %d %d L\n",(int)*x1,(int)*yy1,(int)*x2,(int)*y2));
}

void C2F(drawsegmentsXfig)(char *str, integer *vx, integer *vy, integer *n, integer *style, integer *iflag, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  integer NDvalue,i;
  int l_style,style_val,pen_color,fill_color,areafill;
  integer verbose=0,Dnarg,Dvalue[10],Dvalue1[10];

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  /* store the current values */

  /* F.Leray 08.03.04 Init. here for Dvalue[0]: Pb here what is the correct value for Dvalue[0] ?? */
  Dvalue[0] = 1;

  for ( i =0 ; i < *n/2 ; i++)
    {
      if ( (int) *iflag == 0) 
        NDvalue=(*style < 0) ? Dvalue[0] : *style;
      else
        NDvalue=(int) style[i];


      set_color(NDvalue,&pen_color);
      C2F(getdashXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
      set_dash(Dvalue1[0],&l_style,&style_val);

      areafill = -1;
      fill_color = WHITE;
      FPRINTF((file,"# Object : %d %s -<%d>- \n", (int)i,"segments", ScilabGCXfig.CurPattern));
      FPRINTF((file,"2 1 %d %d %d %d 0 0 -1 %d.000 0 0 0 0 0 2\n",
              l_style,
              ScilabGCXfig.CurLineWidth*prec_fact/16,
              pen_color,fill_color,
              style_val
              ));
      FPRINTF((file," %d %d %d %d \n",
              (int)vx[2*i], (int)vy[2*i], (int)vx[2*i+1], (int)vy[2*i+1]));
    }
}

void C2F(drawarrowsXfig)(char *str, integer *vx, integer *vy, integer *n, integer *as, integer *style, integer *iflag, double *dx1, double *dx2, double *dx3, double *dx4)
{
  int i;
  int l_style,style_val,pen_color,fill_color,areafill;
  integer verbose=0,Dnarg,Dvalue[10],Dvalue1[10],NDvalue;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  /* store the current values */
  C2F(getdashXfig)(&verbose,Dvalue,&Dnarg,vdouble);
  for ( i = 0 ; i < *n/2 ; i++)
    {
      if ( (int) *iflag == 0) 
        NDvalue=(*style < 0) ? Dvalue[0] : *style;
      else
        NDvalue=(int) style[i];


      set_color(NDvalue,&pen_color);
      C2F(getdashXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
           set_dash(Dvalue1[0],&l_style,&style_val);
      areafill = -1;
      fill_color = WHITE;
      FPRINTF((file,"# Object : %d %s -<%d>-\n", (int)i,"arrows", ScilabGCXfig.CurPattern));
      FPRINTF((file,"2 1 %d %d %d %d 0 0 -1 %d.000 0 0 0 1 0 2\n",
              l_style,
              ScilabGCXfig.CurLineWidth*prec_fact/16,
              pen_color,fill_color,
              style_val
              ));
      FPRINTF((file,"    0 0 %d %d %d\n",
              (int)(1*prec_fact/16), (int)(3*prec_fact), (int) (6*prec_fact)));
      FPRINTF((file," %d %d %d %d \n",
              (int)vx[2*i], (int)vy[2*i], (int)vx[2*i+1], (int)vy[2*i+1]));
    }
}

void C2F(drawrectangleXfig)(char *str, integer *x, integer *y, integer *width, integer *height, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i = 1;
  integer fvect[1] ;
  integer vects[4];
  vects[0]= *x;vects[1]= *y;vects[2]= *width;
  vects[3]= *height;
  fvect[0] = 0;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  C2F(drawrectanglesXfig)(str,vects,fvect,&i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
}

void C2F(fillrectangleXfig)(char *str, integer *x, integer *y, integer *width, integer *height, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i = 1;
  integer vects[4],verb=0,cpat,num;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  vects[0]= *x;vects[1]= *y;vects[2]= *width;
  vects[3]= *height ; 
  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  C2F(drawrectanglesXfig)(str,vects,&cpat,&i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);    
}

void C2F(drawrectanglesXfig)(char *str, integer *vects, integer *fillvect, integer *n, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  integer cpat,verb,num;
  verb=0;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  C2F(WriteGenericXfig)("drawbox",*n,(integer)4L,vects,vects,4*(*n),(integer)0L,fillvect);
  C2F(setpatternXfig)(&(cpat),PI0,PI0,PI0);
}


/* old version no more used because it allows only full ellipse */
void C2F(fillarcsXfig_old)(char *str, integer *vects, integer *fillvect, integer *n, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  integer cpat,verb,num;
  verb=0;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }


  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  C2F(WriteGenericXfig)("drawarc",*n,(integer)6L,vects,vects,6*(*n),(integer)0L,fillvect);
  C2F(setpatternXfig)(&(cpat),PI0,PI0,PI0);
}

void C2F(fillarcsXfig)(char *str, integer *vects, integer *fillvect, integer *n, integer *v5, integer *v6, integer *v7, double *dv1, double *dv2, double *dv3, double *dv4)
{
  integer verbose=0,Dnarg,pat;
  int i,i6;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  /* store the current values */
  C2F(getpatternXfig)(&verbose,&pat,&Dnarg,vdouble);
  for ( i=0 ; i < *n ; i++) 
    {
      C2F(setpatternXfig)(&fillvect[i],PI0,PI0,PI0);
      i6=6*i;
      C2F(fillarcXfig)(str,&(vects[i6]),&(vects[i6+1]),&(vects[i6+2]),
                      &(vects[i6+3]),&(vects[i6+4]),&(vects[i6+5]) ,dv1, dv2, dv3, dv4);

    }
  C2F(setpatternXfig)(&pat,PI0,PI0,PI0);
}


/* Old definition no more used because it allows only full ellipse */
void C2F(drawarcsXfig_old)(char *str, integer *vects, integer *style, integer *n, integer *v5, integer *v6, integer *v7, double *dv1, double *dv2, double *dv3, double *dv4)
{
  integer verbose=0,Dnarg,Dvalue[10];
  /* store the current values */

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(getdashXfig)(&verbose,Dvalue,&Dnarg,vdouble);
  C2F(WriteGenericXfig)("Rdrawarc",*n,(integer)6L,vects,vects,6*(*n),(integer)0L,style);
  C2F(setdashXfig)( Dvalue,PI0,PI0,PI0);
}

void C2F(drawarcsXfig)(char *str, integer *vects, integer *style, integer *n, integer *v5, integer *v6, integer *v7, double *dv1, double *dv2, double *dv3, double *dv4)
{
  integer verbose=0,Dnarg,Dvalue[10],NDvalue;
  int i,i6;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  /* store the current values */
  C2F(get_dash_and_color_Xfig)(&verbose,Dvalue,&Dnarg,vdouble);
  for ( i=0 ; i < *n ; i++) 
    {
      NDvalue = style[i];
      C2F(set_line_style_Xfig)(&NDvalue,PI0,PI0,PI0);
      i6=6*i;
      C2F(drawarcXfig)(str,vects+i6,vects+(i6+1),vects+(i6+2),vects+(i6+3),
                      vects+(i6+4),vects+(i6+5) , dv1, dv2, dv3, dv4);
    }
  C2F(set_dash_and_color_Xfig)( Dvalue,PI0,PI0,PI0);
}


/*  Old definition no more used  because it allows only full ellipse */

void C2F(drawarcXfig_old)(char *str, integer *x, integer *y, integer *width, integer *height, integer *angle1, integer *angle2, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i =1;
  integer fvect[1] ;
  integer vects[6];

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  vects[0]= *x;vects[1]= *y;vects[2]= *width;
  vects[3]= *height;vects[4]= *angle1;vects[5]= *angle2;
  fvect[0] = ScilabGCXfig.IDLastPattern  +2;
  C2F(fillarcsXfig)(str,vects,fvect,&i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
}

void C2F(drawarcXfig)(char *str, integer *x, integer *y, integer *width, integer *height, integer *angle1, integer *angle2, double *dv1, double *dv2, double *dv3, double *dv4)
{ 
  integer vx[365],vy[365],k,n;
  float alpha,fact= (float) 0.01745329251994330,w,h;
  integer close = 0;  

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  w = (float) ((*width)/2.0);
  h = (float) ((*height)/2.0);
  n=Min((*angle2/64),360);
  for (k = 0; k < n; ++k) {
    alpha=((*angle1/64)+k)*fact;
    vx[k] = (integer) (*x + w*(cos(alpha)+1.0));
    vy[k] = (integer) (*y + h*(-sin(alpha)+1.0));}
    
  /* Fix bug 1737 : if n==360 we want a closed circle */
  if(n == 360) close = 1;

  C2F(drawClippedPolylineXfig)(str, &n, vx, vy, &close, PI0, PI0, dv1, dv2, dv3, dv4);
}


/* Old definition commented out because it allows only full ellipse */
void C2F(fillarcXfig_old)(char *str, integer *x, integer *y, integer *width, integer *height, integer *angle1, integer *angle2, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i =1;
  integer verb=0,cpat,num ;
  integer vects[6];

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  vects[0]= *x;vects[1]= *y;vects[2]= *width;
  vects[3]= *height;vects[4]= *angle1;vects[5]= *angle2;
  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  C2F(fillarcsXfig)(str,vects,&cpat,&i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
 }

void C2F(fillarcXfig)(char *str, integer *x, integer *y, integer *width, integer *height, integer *angle1, integer *angle2, double *dv1, double *dv2, double *dv3, double *dv4)
{ 
  integer vx[365],vy[365],k,k0,kmax,n;
  float alpha,fact= (float) 0.01745329251994330,w,h;
  integer close = 1;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  n=Min((*angle2/64),360);

  w = (float) ((*width)/2.0);
  h = (float) ((*height)/2.0);
  k0 = 0;
  kmax = n-1;

  if (n != 360) {
  vx[0] = (integer) (*x + w);
  vy[0] = (integer) (*y + h);
  k0 = 1;
  kmax = n;}

  for (k = k0; k <= kmax; ++k) {
    alpha=((*angle1/64)+k)*fact;
    vx[k] = (integer) (*x + w*(cos(alpha)+1.0));
    vy[k] = (integer) (*y + h*(-sin(alpha)+1.0));}
  if (n != 360) {
  n++;
  vx[n] = (integer) (*x + ((*width)/2.0));
  vy[n] = (integer) (*y + ((*height)/2.0)); 
  n++;
  }
  C2F(fillpolylineXfig)(str, &n, vx, vy, &close, PI0, PI0, dv1, dv2, dv3, dv4);
 }




void C2F(drawpolymarkXfig)(char *str, integer *n, integer *vx, integer *vy, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer keepid,keepsize,  i=1, sz;
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  sz=ScilabGCXfig.CurHardSymbSize;
  keepid =  ScilabGCXfig.FontId;
  keepsize= ScilabGCXfig.FontSize;
  C2F(xsetfontXfig)(&i,&sz,PI0,PI0);
  C2F(displaysymbolsXfig)(str,n,vx,vy);
  C2F(xsetfontXfig)(&keepid,&keepsize,PI0,PI0);
}

char symb_listXfig_[] = {
  /*
     0x2e : . alors que 0xb7 est un o plein trop gros 
     ., +,X,*,diamond(filled),diamond,triangle up,triangle down,trefle,circle*/
  (char)0x2e,(char)0x2b,(char)0xb4,(char)0xc5,(char)0xa8,
  (char)0xe0,(char)0x44,(char)0xd1,(char)0xa7,(char)0x4f};

static void C2F(displaysymbolsXfig)(char *str, integer *n, integer *vx, integer *vy)
{
  integer fvect[1];
  
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }
  
  fvect[0] =      ScilabGCXfig.CurPattern;
  if ( ScilabGCXfig.CurVectorStyle !=  CoordModeOrigin)
    FPRINTF((file,"#/absolu false def\n"));
  FPRINTF((file,"#HardMark 0 16#%x put\n",
      Char2Int( symb_listXfig_[ScilabGCXfig.CurHardSymb])));
  C2F(WriteGenericXfig)("drawpolymark",(integer)1L,(*n)*2,vx,vy,*n,(integer)1L,fvect);
  FPRINTF((file,"#/absolu true def\n"));
}

void C2F(drawpolylinesXfig)(char *str, integer *vectsx, integer *vectsy, integer *drawvect, integer *n, integer *p, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ integer verbose ,symb[2],Mnarg,Dnarg,Dvalue[10],NDvalue,i,close;
  verbose =0 ;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  /* store the current values */
  C2F(getcursymbolXfig)(&verbose,symb,&Mnarg,vdouble);
  C2F(get_dash_and_color_Xfig)(&verbose,Dvalue,&Dnarg,vdouble);
  for (i=0 ; i< *n ; i++)
    {
      if (drawvect[i] <= 0)
        { 
          NDvalue = - drawvect[i] ;
          C2F(setcursymbolXfig)(&NDvalue,symb+1,PI0,PI0);
          C2F(setdashXfig)(Dvalue,PI0,PI0,PI0);
         
          C2F(drawpolymarkXfig)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
        }
      else 
        {
          C2F(set_line_style_Xfig)(drawvect+i,PI0,PI0,PI0);
          close = 0;
          C2F(drawClippedPolylineXfig)(str,p,vectsx+(*p)*i,vectsy+(*p)*i,&close,PI0,PI0,PD0,PD0,PD0,PD0);
        }
    }
  C2F(set_dash_and_color_Xfig)(Dvalue,PI0,PI0,PI0);
  C2F(setcursymbolXfig)(symb,symb+1,PI0,PI0);
}
/*----------------------------------------------------------------------------------*/
/* for the fig driver we need to know if we have at least three distincts points
   for polygons and 2 for lines */
static BOOL checkPolygon( integer *polyX, integer *polyY, integer length )
{
  
  
  if ( length <= 2 )
  {
    return TRUE ;
  }
  else
  {
    int i, j   ;
    int nbDiff = 0 ;
    /* real polygon */
    for ( i = 0 ; i < length ; i++ )
    {
      for ( j = i + 1 ; j < length ; j++ )
      {
        if ( polyX[j] != polyX[i] || polyY[j] != polyY[i] )
        {
          nbDiff++ ;
          if ( nbDiff >= 3 )
          {
            /* 3 distincts points have been found */
            return TRUE ;
          }
        }
      }
    }
  }
  return FALSE ;
}
/*----------------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------------*/
/* for the fig driver we need to know if we have at least three distincts points */
/* for each polygon */
static BOOL checkPolygons( integer *polyX, integer *polyY, integer polyLength, integer nbPoly )
{
  int   i                ;
  int * curPolyX = polyX ;
  int * curPolyY = polyY ;
  for ( i = 0 ; i < nbPoly ; i++ )
  {
    /* check every pairs of points in the polygon */
    if ( !checkPolygon( curPolyX, curPolyY, polyLength ) )
    {
      return FALSE ;
    }
    /* get the pointer on the next polygon */
    curPolyX += polyLength ;
    curPolyY += polyLength ;
  }
  return TRUE ;
}



/*----------------------------------------------------------------------------------*/

/*  if fillvect[i] == 0 draw the boundaries with current color 
    if fillvect[i] > 0  draw the boundaries with current color 
    then fill with pattern fillvect[i]
    if fillvect[i] < 0  fill with pattern - fillvect[i]
*/


void C2F(fillpolylinesXfig)(char *str, integer *vectsx, integer *vectsy, integer *fillvect, integer *n, integer *p, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  integer cpat,verb,num;
  verb=0;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  /* check if every polygon is not flat */
  if ( !checkPolygons( vectsx, vectsy, *p, *n ) )
  {
    return ;
  }

  if ( ScilabGCXfig.CurVectorStyle !=  CoordModeOrigin )
  {
    FPRINTF( (file,"#/absolu false def\n") ) ;
  }
  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  C2F(WriteGenericXfig)("drawpoly",*n,(*p)*2,vectsx,vectsy,(*p)*(*n),(integer)1L,
                        fillvect);
  C2F(setpatternXfig)(&(cpat),PI0,PI0,PI0);
  FPRINTF((file,"#/absolu true def\n"));
}

/*
 * same as drawpolylineXfig but don't perform clipping
 */

void C2F(drawClippedPolylineXfig)(char *str, integer *n, integer *vx, integer *vy, integer *closeflag, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i=1,fvect=0;
  integer *vxtmp = NULL;
  integer *vytmp = NULL;
  int j;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if((vxtmp=MALLOC(((*n)+1)*sizeof(integer)))==0){
    sciprint("Can not allocate vxtmp while exporting to Fig\n");
    return;
  }
  
  if((vytmp=MALLOC(((*n)+1)*sizeof(integer)))==0){
    sciprint("Can not allocate vxtmp while exporting to Fig\n");
    return;
  }

  
  for( j = 0 ; j < (*n ) ; j++ )
  {
    vxtmp[j] = vx[j];
    vytmp[j] = vy[j];
  }
  
  vxtmp[(*n)] = vx[0];
  vytmp[(*n)] = vy[0];

  if (*closeflag == 1 ){
    int nb = (*n)+1;
    FPRINTF((file,"#/closeflag true def\n"));
    if (ScilabGCXfig.ClipRegionSet ==1 )
      {
        C2F(analyze_pointsXfig)(nb, vxtmp, vytmp, *closeflag);
      }
    else     
    C2F(fillpolylinesXfig)(str,vxtmp,vytmp,&fvect,&i,&nb,PI0,PD0,PD0,PD0,PD0);
  }
  else {
    FPRINTF((file,"#/closeflag false def\n"));
    if (ScilabGCXfig.ClipRegionSet ==1 )
      {
        C2F(analyze_pointsXfig)(*n, vx, vy, *closeflag);
      }
    else 
    C2F(fillpolylinesXfig)(str,vx,vy,&fvect,&i,n,PI0,PD0,PD0,PD0,PD0);
  }

  FREE(vxtmp); vxtmp = NULL;
  FREE(vytmp); vytmp = NULL;

  /*   if (*closeflag == 1 ) */
  /*     FPRINTF((file,"#/closeflag true def\n")); */
  /*   else  */
  /*     FPRINTF((file,"#/closeflag false def\n")); */
  /*   if (ScilabGCXfig.ClipRegionSet ==1 ) */
  /*     { */
  /*       C2F(analyze_pointsXfig)(*n, vx, vy, *closeflag); */
  /*     } */
  /*   else  */
  /*     C2F(fillpolylinesXfig)(str,vx,vy,&fvect,&i,n,PI0,PD0,PD0,PD0,PD0); */
}


/* F.Leray */
/* closeflag is emulated adding starting points at the end of *vx and *vy */

void C2F(drawpolylineXfig)(char *str, integer *n, integer *vx, integer *vy, integer *closeflag, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i=1,fvect=0;
  integer *vxtmp = NULL;
  integer *vytmp = NULL;
  int j;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if((vxtmp=MALLOC(((*n)+1)*sizeof(integer)))==0){
    sciprint("Can not allocate vxtmp while exporting to Fig\n");
    return;
  }
  
  if((vytmp=MALLOC(((*n)+1)*sizeof(integer)))==0){
    sciprint("Can not allocate vxtmp while exporting to Fig\n");
    return;
  }

  
  for( j = 0 ; j < (*n ) ; j++ )
  {
    vxtmp[j] = vx[j];
    vytmp[j] = vy[j];
  }
  
  vxtmp[(*n)] = vx[0];
  vytmp[(*n)] = vy[0];

  if (*closeflag == 1 ){
    int nb = (*n)+1;
    FPRINTF((file,"#/closeflag true def\n"));
    C2F(fillpolylinesXfig)(str,vxtmp,vytmp,&fvect,&i,&nb,PI0,PD0,PD0,PD0,PD0);
  }
  else {
    FPRINTF((file,"#/closeflag false def\n"));
    C2F(fillpolylinesXfig)(str,vx,vy,&fvect,&i,n,PI0,PD0,PD0,PD0,PD0);
  }

  FREE(vxtmp); vxtmp = NULL;
  FREE(vytmp); vytmp = NULL;

  /*   if (*closeflag == 1 ) */
  /*     FPRINTF((file,"#/closeflag true def\n")); */
  /*   else  */
  /*     FPRINTF((file,"#/closeflag false def\n")); */
  /*   if (ScilabGCXfig.ClipRegionSet ==1 ) */
  /*     { */
  /*       C2F(analyze_pointsXfig)(*n, vx, vy, *closeflag); */
  /*     } */
  /*   else  */
  /*     C2F(fillpolylinesXfig)(str,vx,vy,&fvect,&i,n,PI0,PD0,PD0,PD0,PD0); */
}

void C2F(fillpolylineXfig)(char *str, integer *n, integer *vx, integer *vy, integer *closeareaflag, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  integer i = 1;
  integer cpat,verb=0,num;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  cpat = -cpat;
/*   C2F(analyze_pointsXfigForFilling)(*n, vx, vy, 1, cpat); */
  C2F(fillpolylinesXfig)(str,vx,vy,&cpat,&i,n,PI0,PD0,PD0,PD0,PD0);
}
 
/*-----------------------------------------------------
\encadre{Routine for initialisation}
------------------------------------------------------*/


void C2F(initgraphicXfig)(char *string, integer *v2, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  char string1[50];
  static integer EntryCounter = 0;
  integer fnum;
  *v3 = 0;
  if (EntryCounter >= 1) C2F(xendgraphicXfig)();
  strcpy(string1,string);
  file=fopen(string1,"w");
  if (file == 0) 
    {
      /*sciprint("Can't open file %s, I'll use stdout\r\n",string1);*/
      file = stdout;
      *v3 = 1;
      return;
    }
  if (EntryCounter == 0)
    { 
      fnum=0;      C2F(loadfamilyXfig)("Courier",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=1;      C2F(loadfamilyXfig)("Symbol",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=2;      C2F(loadfamilyXfig)("Times-Roman",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
      fnum=3;      C2F(loadfamilyXfig)("Times-Italic",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=4;      C2F(loadfamilyXfig)("Times-Bold",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
      fnum=5;      C2F(loadfamilyXfig)("Times-BoldItalic",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=6;      C2F(loadfamilyXfig)("Helvetica",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=7;      C2F(loadfamilyXfig)("Helvetica-Oblique",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=8;      C2F(loadfamilyXfig)("Helvetica-Bold",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=9;      C2F(loadfamilyXfig)("Helvetica-BoldOblique",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
    }
  C2F(FileInitXfig)();
  ScilabGCXfig.CurWindow =EntryCounter;
  EntryCounter =EntryCounter +1;
}

static void C2F(FileInitXfig)(void)
{
  int m;
  integer x[2],verbose,narg;
  verbose = 0; 
  C2F(getwindowdimXfig)(&verbose,x,&narg,vdouble);
  FPRINTF((file,"#FIG 3.1\nPortrait\nCenter\nInches\n1200 2\n"));
  ScilabGCXfig_is_initialized = TRUE; /* add the flag ScilabGCXfig_is_initialized to test if xinit has been called */
  C2F(InitScilabGCXfig)(PI0,PI0,PI0,PI0);

  m = DEFAULTNUMCOLORS;
  ScilabGCXfig.Numcolors = m;
  ScilabGCXfig.IDLastPattern = m - 1;
  ScilabGCXfig.NumForeground = m;
  ScilabGCXfig.NumBackground = m + 1;
  FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m,0,0,0));
  FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m+1,255,255,255));
  
/*     } */

  FPRINTF((file,"2 2 0 0 -1 -1 0 0 -1 0.000 0 0 0 0 0 5\n"));
  FPRINTF((file," %d %d %d %d %d %d %d %d %d %d \n",
           0,0,(int)x[0],0,(int)x[0],(int)x[1],0,(int)x[1],0,0));
}

/*--------------------------------------------------------
\encadre{Initialisation of the graphic context. Used also 
to come back to the default graphic state}
---------------------------------------------------------*/

void C2F(InitScilabGCXfig)(integer *v1, integer *v2, integer *v3, integer *v4)
{ integer i,j,col;
  ScilabGCXfig.IDLastPattern = GREYNUMBER - 1; 
  ScilabGCXfig.CurLineWidth=1 ;
  i=1;
  C2F(setthicknessXfig)(&i,PI0,PI0,PI0);
  C2F(setalufunctionXfig)("GXcopy");
  i=j= -1;
  C2F(unsetclipXfig)(PI0,PI0,PI0,PI0);
  C2F(setdashXfig)((i=0,&i),PI0,PI0,PI0);
  C2F(xsetfontXfig)((i=2,&i),(j=1,&j),PI0,PI0);
  C2F(setcursymbolXfig)((i=0,&i),(j=0,&j),PI0,PI0);
  ScilabGCXfig.CurVectorStyle = CoordModeOrigin ;
  /* initialisation des pattern dash par defaut en n&b */
  ScilabGCXfig.CurColorStatus =0;
  C2F(setpatternXfig)((i=1,&i),PI0,PI0,PI0);
  C2F(setdashXfig)((i=1,&i),PI0,PI0,PI0);
  C2F(sethidden3dXfig)((i=1,&i),PI0,PI0,PI0);
  /* initialisation de la couleur par defaut */ 
  ScilabGCXfig.Numcolors = DEFAULTNUMCOLORS;
  ScilabGCXfig.CurColorStatus = 1 ;
  C2F(setpatternXfig)((i=1,&i),PI0,PI0,PI0);
  C2F(setforegroundXfig)((i=ScilabGCXfig.NumForeground+1,&i),PI0,PI0,PI0);
  C2F(setbackgroundXfig)((i=ScilabGCXfig.NumForeground+2,&i),PI0,PI0,PI0);
  C2F(sethidden3dXfig)((i=4,&i),PI0,PI0,PI0);
  /* Choix du mode par defaut (decide dans initgraphic_ */
  getcolordef(&col);
  ScilabGCXfig.mafigure = (sciPointObj *)NULL;
  ScilabGCXfig.CurColorStatus = (col == 1) ? 0: 1;
  C2F(usecolorXfig)(&col,PI0,PI0,PI0);
  if (col == 1) ScilabGCXfig.IDLastPattern = ScilabGCXfig.Numcolors - 1;
  strcpy(ScilabGCXfig.CurNumberDispFormat,"%-5.2g");
}


/*-------------------------------------------------------
\encadre{Check if a specified family of font exist in 
Postscript }
-------------------------------------------------------*/

void C2F(loadfamilyXfig)(char *name, integer *j, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  integer i ;
  for ( i = 0; i < FONTMAXSIZE ; i++)
    {
      FontsListXfig_[*j][i] = C2F(FigQueryFont)(name);
    }
  if  (FontsListXfig_[*j][0] == 0 )
          sciprint("\n unknown font family : %s\r\n",name);
  else 
    {FontInfoTabXfig_[*j].ok = 1;
     strcpy(FontInfoTabXfig_[*j].fname,name) ;}
}

void C2F(queryfamilyXfig)(char *name, integer *j, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dv1, double *dv2, double *dv3, double *dv4)
{ 
  integer i ;
  name[0]='\0';
  for (i=0;i<FONTNUMBER;i++) {
    strcat(name,FontInfoTabXfig_[i].fname);
    v3[i]=strlen(FontInfoTabXfig_[i].fname);
  }
  *j=FONTNUMBER;
}
/*--------------------------------------------
\encadre{always answer ok. Must be Finished}
---------------------------------------------*/

static int C2F(FigQueryFont)(char *name)
{ return(1);}


/*------------------------------------------------------
  \encadre{Draw an axis whith a slope of alpha degree (clockwise)
  . Along the axis marks are set in the direction ( alpha + pi/2), in the 
  following way :
  \begin{itemize}
  \item   $n=<n1,n2>$,
  \begin{verbatim}
  |            |           |
  |----|---|---|---|---|---|
  <-----n1---->                 
  <-------------n2-------->
  \end{verbatim}
  $n1$and $n2$ are integer numbers for interval numbers.
  \item $size=<dl,r,coeff>$. $dl$ distance in points between 
  two marks, $r$ size in points of small mark, $r*coeff$ 
  size in points of big marks. (they are doubleing points numbers)
  \item $init$. Initial pointeger $<x,y>$. 
  \end{itemize}
  }
  -------------------------------------------------------------*/

void C2F(drawaxisXfig)(char *str, integer *alpha, integer *nsteps, integer *v2, integer *initpoint, integer *v6, integer *v7, double *size, double *dx2, double *dx3, double *dx4)
{ integer i;
  int l_style,style_val,pen_color;
  double xi,yi,xf,yf;
  double cosal,sinal;
  integer verbose=0,Dnarg,Dvalue1[10];

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(getdashXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
  set_dash_or_color(Dvalue1[0],&l_style,&style_val,&pen_color);
  FPRINTF((file,"# Begin Axis \n"));
  if ( *alpha == 90 )
    {cosal = 0.0 ; sinal =1.0 ;}
  else 
   {
     if ( *alpha == -90 )
       {cosal = 0.0 ; sinal = -1.0 ;}
     else 
       {
         cosal= cos( M_PI * (*alpha)/180.0);
         sinal= sin( M_PI * (*alpha)/180.0);
       }
   }
  for (i=0; i <= nsteps[0]*nsteps[1]; i++)
    { xi = initpoint[0]+i*size[0]*cosal;
      yi = initpoint[1]+i*size[0]*sinal;
      xf = xi - ( size[1]*sinal);
      yf = yi + ( size[1]*cosal);
      FPRINTF((file,"2 1 0 %d %d %d 0 0 -1 0.000 0 0 0 0 0 2\n",
              ScilabGCXfig.CurLineWidth*prec_fact/16,
              pen_color,
              pen_color
              ));
      FPRINTF((file," %d %d %d %d \n",(int)xi, (int)yi,  (int)  xf, (int)yf));
    }
  for (i=0; i <= nsteps[1]; i++)
    { xi = initpoint[0]+i*nsteps[0]*size[0]*cosal;
      yi = initpoint[1]+i*nsteps[0]*size[0]*sinal;
      xf = xi - ( size[1]*size[2]*sinal);
      yf = yi + ( size[1]*size[2]*cosal);
      FPRINTF((file,"2 1 0 %d %d %d 0 0 -1 0.000 0 0 0 0 0 2\n",
              ScilabGCXfig.CurLineWidth*prec_fact/16,
              pen_color,
              pen_color
              ));
      FPRINTF((file," %d %d %d %d \n", (int)xi, (int) yi, (int)xf, (int)yf));
    }
  xi = initpoint[0]; yi= initpoint[1];
  xf = initpoint[0]+ nsteps[0]*nsteps[1]*size[0]*cosal;
  yf = initpoint[1]+ nsteps[0]*nsteps[1]*size[0]*sinal;
  FPRINTF((file,"2 1 0 %d %d %d 0 0 -1 0.000 0 0 0 0 0 2\n",
          ScilabGCXfig.CurLineWidth*prec_fact/16,
          pen_color,
          pen_color));
  FPRINTF((file," %d %d %d %d \n",  (int)xi,  (int)yi, (int) xf, (int)yf));
  FPRINTF((file,"# End Of Axis \n"));
}

/*------------------------------------------------------------------------------------------*/
void C2F(getFontMaxSizeXfig)(char *str, integer * sizeMin, integer *sizeMax, integer *v1, integer *v2, integer *v3, integer *v4, double *dx1, double *dx2, double *dx3, double *dx4)
{
  *sizeMin = 0 ;
  *sizeMax = FONTMAXSIZE ;
}
/*------------------------------------------------------------------------------------------*/

/*-----------------------------------------------------
\encadre{Display numbers z[i] at location (x[i],y[i])
  with a slope alpha[i] (see displaystring_), if flag==1
  add a box around the string.
-----------------------------------------------------*/
void C2F(displaynumbersXfig)(char *str, integer *x, integer *y, integer *v1, integer *v2, integer *n, integer *flag, double *z, double *alpha, double *dx3, double *dx4)
{ integer i ;
  char buf[20];

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  for (i=0 ; i< *n ; i++)
    { 
      sprintf(buf,ScilabGCXfig.CurNumberDispFormat,z[i]);
      C2F(displaystringXfig)(buf,&(x[i]),&(y[i]),PI0,flag,PI0,PI0,&(alpha[i]),PD0,PD0,PD0);
    }
}

/*-------------------------------------------------------
\encadre{General routine for generating Postscript Code 
to deal with Vectors. The difficulty is that the size 
of vectors is limited by Postscript, so the routine 
must check size and cut into pieces big objects}
\begin{verbatim}
  clear (string) sizeobj [fvect[0],...,fvect[nobj]]
  (si flag=1)  [ vx[0] vy[0] vx[1] vy[1] ...... vx[sizev] vy[sizev]]
  (si flag=0)  [ vx[0] vx[1] ..... vx[sizev] ] dogrey 
\end{verbatim}
----------------------------------------------------------*/


/*****************************************************************************
 * give the correct pattern for xfig 0=white-> 20=black 
 * from our pattern coding 0=black    ScilabGCXfig.IDLastPattern=white 
 *  we use xfig as follows : 
 *  when use_color == 1 we use the 32 standard colors of xfig with 20 ( full saturation )
 *  as fill area 
 *  when use_color == 0 we use the white color + areafill from 0 to 20 to generate 
 *  shades of gray 
 * XXXXXX : xset("colormap") must be implemented 
 *******************************************************************************/

#define AREAF(x) Max(0,Min(20,(int) (20.0*((double) x) /((double) GREYNUMBER -1 ))))

void set_pattern_or_color(int pat, int *areafill, int *color)
{
  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if (  ScilabGCXfig.CurColorStatus == 1) 
    {
      int m;
      *color = pat-1 ; 
      if (  CheckColormap(&m) == 1) 
        {
          *color += 32;
        }
      else 
        {
          /* special case for B&white in the default colormap */
          if ( *color == 32 ) 
            {
              *color = DEFAULTBLACK;
            }
          else if ( *color == 33 ) 
            {
              *color = DEFAULTWHITE;
            }
        }
      *areafill = 20 ; 
    }
  else 
    {
      *color = WHITE ; 
      *areafill = AREAF(pat-1); 
    }
}



static void set_color(int c, int *color)
{
  int m;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if (  ScilabGCXfig.CurColorStatus == 0) {
    *color=0;
    return;
  }
  *color = c-1 ; 
  if (  CheckColormap(&m) == 1) 
    {
      *color += 32;
    }
  else 
    {
      /* special case for B&white in the default colormap */
      if ( *color == 32 ) 
        {
          *color = DEFAULTBLACK;
        }
      else if ( *color == 33 ) 
        {
          *color = DEFAULTWHITE;
        }
    }
}

static void set_dash(int dash, int *l_style, int *style_val)
{
  int i;
  i = Max(Min(MAXDASH -1,dash-1),0);
  *l_style = DashTab[i];
  *style_val = DashTabStyle[i];
}

static void set_dash_or_color(int dash, int *l_style, int *style_val, int *color)
{
  int j;  

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  if (  ScilabGCXfig.CurColorStatus == 1) 
    {
      j= ScilabGCXfig.CurDashStyle + 1;
      set_dash(j,l_style,style_val);
      set_color(dash,color);
      *l_style = 0 ;
      *style_val=0;
    }
  else 
    {
      set_dash(dash,l_style,style_val);
      *color = BLACK;
    }
}


#define PERLINE 15

#define FORMATNUM "%d "

void C2F(WriteGenericXfig)(char *string, integer nobj, integer sizeobj, integer *vx, integer *vy, integer sizev, integer flag, integer *fvect)
{ 
  integer i;
  integer verb=0,cpat,num;
  integer verbose=0,Dnarg,Dvalue[10],Dvalue1[10];
  integer lg,type=1 ;
  integer areafill,fill_color,pen_color,l_style,style_val;

  if ( ScilabGCXfig_is_initialized == FALSE ) {
    sciprint("xinit must be called before any action \r\n");
    return;
  }

  C2F(getdashXfig)(&verb,Dvalue,&Dnarg,vdouble);
  C2F(getpatternXfig)(&verb,&cpat,&num,vdouble);
  if ( nobj==0|| sizeobj==0) return;
  
  if ( strcmp(string,"drawpoly") == 0 )
  {
    for ( i = 0 ; i < nobj ; i++ )
    {
      lg = sizeobj / 2 ;

      if ( fvect[i] < 0 )
      {
        set_pattern_or_color( - fvect[i], &areafill, &fill_color ) ;
        l_style = 0;
        style_val = 0;
        pen_color = fill_color;
        type = 3;
      }
      else if ( fvect[i] == 0 )
      {
        set_color(cpat,&pen_color);
        set_dash(Dvalue[0],&l_style,&style_val);
        areafill=-1;
        fill_color = WHITE;
      }
      else 
      { 
        set_pattern_or_color(fvect[i],&areafill,&fill_color);
        set_color(cpat,&pen_color);
        set_dash(Dvalue[0],&l_style,&style_val);
        /*set_dash_or_color(Dvalue[0],&l_style,&style_val,&pen_color);*/
        type=3;
      }
      
      FPRINTF((file,"# Object : %d %s -<pat:%d,areafill=%d,white=%d>- \n", (int)i,string,
               (int)fvect[i],
               (int)areafill,
               ScilabGCXfig.IDLastPattern));
      FPRINTF((file,"2 %d %d %d %d %d 0 0 %d %d.00 0 0 -1 0 0 %d\n",
               (int)type,l_style, ScilabGCXfig.CurLineWidth*prec_fact/16,
               pen_color,fill_color,areafill,style_val, (int)lg
                ));

      /* debug info.*/
      /*   printf("# Object : %d %s -<pat:%d,areafill=%d,white=%d>- \n", (int)i,string, */
/*               (int)fvect[i], */
/*               (int)areafill, */
/*               ScilabGCXfig.IDLastPattern); */
/*        printf("2 %d %d %d %d %d 0 0 %d %d.00 0 0 -1 0 0 %d\n", */
/*               (int)type,l_style, ScilabGCXfig.CurLineWidth*prec_fact/16, */
/*               pen_color,fill_color,areafill,style_val, (int)lg); */
/*        fflush(NULL); */
      C2F(Write2VectXfig)(&vx[i*lg],&vy[i*lg],lg,flag);
    }
  }
  else 
  if ( strcmp(string,"drawbox")==0)
    {
      for ( i =0 ; i < nobj ; i++)
        {
          integer deb;
          if (fvect[i] < 0  )
            {
              set_dash(Dvalue[0],&l_style,&style_val);
              set_color( -fvect[i],&pen_color);
              /*set_dash_or_color( -fvect[i],&l_style,&style_val,&pen_color);*/
              areafill = -1;
              fill_color = WHITE;
            }
          else    if (fvect[i] == 0  )
            {
              set_dash(Dvalue[0],&l_style,&style_val);
              set_color(cpat,&pen_color);
              /*set_dash_or_color(Dvalue[0],&l_style,&style_val,&pen_color);*/
              areafill = -1;
              fill_color = WHITE;
            }
          else 
            {
              set_pattern_or_color(fvect[i],&areafill,&fill_color);
              pen_color = fill_color;
              l_style = 0;
              style_val = 0;
              type = 3;
            }
          FPRINTF((file,"# Object : %d %s -<%d>- \n", (int)i,string, (int)fvect[i]));
          FPRINTF((file,"2 2 %d %d %d %d 0 0 %d %d.000 0 0 0 0 0 5\n",
                  l_style, ScilabGCXfig.CurLineWidth*prec_fact/16,
                  pen_color,fill_color,areafill,style_val));
          deb=i*sizeobj;
          FPRINTF((file," %d %d %d %d %d %d %d %d %d %d \n",
                  (int)vx[deb]                , (int)vx[1+deb],
                  (int)vx[deb]+ (int)vx[2+deb], (int)vx[1+deb],
                  (int)vx[deb]+ (int)vx[2+deb], (int)vx[1+deb]+ (int)vx[3+deb],
                  (int)vx[deb]                , (int)vx[1+deb]+ (int)vx[3+deb],
                  (int)vx[deb]                , (int)vx[1+deb]));
        }
    }
  else if ( strcmp(string,"drawsegs")==0)      
    {
    }
  else if ( strcmp(string,"drawarrows")==0)      
    {
    }
  else if ( strcmp(string,"drawarc")==0)      
    {
      for ( i = 0 ; i < nobj ; i++)
        {
          if (fvect[i] > ScilabGCXfig.IDLastPattern+1 )
            {
              set_dash_or_color(Dvalue[0],&l_style,&style_val,&pen_color);
              areafill = -1;
              fill_color = WHITE;
            }
          else 
            {
              set_pattern_or_color(fvect[i],&areafill,&fill_color);
              pen_color = fill_color;
              l_style = 0;
              style_val = 0;
              type = 3;
            }
          FPRINTF((file,"# Object : %d %s -<%d>-\n", (int)i,string, (int)fvect[0]));
          FPRINTF((file,
                  "1 2 %d %d %d %d 0 0 %d %d.000 1 0.00 %d %d %d %d %d %d %d %d \n",
                  l_style,
                  ScilabGCXfig.CurLineWidth*prec_fact/16,
                  pen_color,fill_color,areafill,style_val,
                  (int)vx[6*i]+ (int)vx[6*i+2]/2, 
                  (int)vx[6*i+1]+ (int)vx[6*i+3]/2,
                  (int)vx[6*i+2]/2, (int)vx[6*i+3]/2,
                  (int)vx[6*i]+ (int)vx[6*i+2]/2, (int)vx[6*i+1],
                  (int)vx[6*i]+ (int)vx[6*i+2]/2, (int)vx[6*i+1]));
        }
    }
  else if ( strcmp(string,"Rdrawarc")==0)      
    {
      /* store the current values */
      for ( i = 0 ; i < nobj ; i++)
        {
          /*C2F(setdashXfig)(&fvect[i],PI0,PI0,PI0);*/

          set_dash(Dvalue[0],&l_style,&style_val);
          set_color(fvect[i],&pen_color);

          /*C2F(getdashXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
            set_dash_or_color(Dvalue1[0],&l_style,&style_val,&pen_color);*/
          areafill = -1;
          fill_color = WHITE;
          FPRINTF((file,"# Object : %d %s -<%d>-\n", (int)i,string, (int)fvect[0]));
          FPRINTF((file,
                  "1 2 %d %d %d %d 0 0 %d %d.000 1 0.00 %d %d %d %d %d %d %d %d \n",
                  l_style,
                  (int) (ScilabGCXfig.CurLineWidth*prec_fact/16),
                  pen_color,fill_color,
                  areafill, 
                  style_val,
                  (int) (vx[6*i]+vx[6*i+2]/2), 
                  (int) (vx[6*i+1]+vx[6*i+3]/2),
                  (int) (vx[6*i+2]/2), (int) (vx[6*i+3]/2),
                  (int) (vx[6*i]+ vx[6*i+2]/2), (int)vx[6*i+1],
                  (int) (vx[6*i]+ vx[6*i+2]/2), (int)vx[6*i+1]));
        }
      /*C2F(setdashXfig)( Dvalue,PI0,PI0,PI0);*/
    }
  else if ( strcmp(string,"drawpolymark")==0)      
    {
      integer rect[4],x=0,y=0;
      C2F(getpatternXfig)(&verbose,Dvalue1,&Dnarg,vdouble);
      set_color(Dvalue1[0],&pen_color);
      l_style=0;style_val=0,
      C2F(boundingboxXfigM)("x",&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
      FPRINTF((file,"# Object : %d %s -<%d>- \n", (int)0,string, (int)fvect[0]));
      for ( i =0 ; i < sizev ; i++)
        {
          flag = 1;
          if ( ScilabGCXfig.ClipRegionSet == 1 ) 
            {
              if ( vx[i] > ScilabGCXfig.CurClipRegion[0] 
                   +ScilabGCXfig.CurClipRegion[2]
                   || vx[i] <  ScilabGCXfig.CurClipRegion[0] 
                   || vy[i] > ScilabGCXfig.CurClipRegion[1] 
                   +ScilabGCXfig.CurClipRegion[3]
                   || vy[i] < ScilabGCXfig.CurClipRegion[1] )
                flag = 0;
            }
          
          if ( flag == 1) 
          FPRINTF((file,"4 1 %d 0 0 %d %d %5.2f %d %5.2f %5.2f %d %d \\%o\\001\n",
                  pen_color,
                  32, /* Postscript font */
                  (int)isizeXfig_[ScilabGCXfig.FontSize], 
                  0.0,
                  4,  
                  (double) rect[3],
                  (double) rect[2],
                  (int)vx[i],
                  (int)vy[i] + rect[3]/2,
                  Char2Int( symb_listXfig_[ScilabGCXfig.CurHardSymb])
                  ));

        }
    }
  else
    sciprint("Can't translate %s\r\n",string);
}

void C2F(Write2VectXfig)(integer *vx, integer *vy, integer n, integer flag)
{
  
  integer i,k;
  
  i=0;     
  while( i < n )
    {
      k=0;
      while ( k < PERLINE && i < n )
        {
          FPRINTF((file,FORMATNUM,(int) vx[i]));
          if (flag == 1) 
            {FPRINTF((file,FORMATNUM,(int) vy[i]));
              k += 2;i++;}
          else 
            {k++;i++;}
        }
      FPRINTF((file,"\n"));
    }
}


/************************************************************
 * Clipping functions for XFig 
 ************************************************************/

static void C2F(analyze_pointsXfig)(integer n, integer *vx, integer *vy, integer onemore)
{
  SClipRegion clipping = getClipRegion( &ScilabGCXfig ) ;

  C2F(clipPolyLine)( n, vx, vy, onemore, &clipping ) ;
}


/* NG beg */
void C2F(setscilabFigureXfig)(integer *v1,integer *v2,integer *v3,integer *v4,integer *v5,integer *v6,double *figure)
{
 figure=(double *)ScilabGCXfig.mafigure;
}

void C2F(getscilabFigureXfig)(integer *verbose, integer *x,integer *narg, double *figure)
{   
  figure=(double *)ScilabGCXfig.mafigure;
}
void C2F(setscilabVersionXfig)(integer *vers, integer *v2, integer *v3, integer *v4)
{
  /*ScilabGCXfig.graphicsversion=*vers;*/
}

void C2F(getscilabVersionXfig)(integer *verbose, integer *vers, integer *narg, double *dummy)
{   
  *vers = 0 ;
}
void C2F(getscilabxgcXfig)(integer *verbose, integer *x,integer *narg, double *dummy)
{   
 double **XGC;
 XGC=(double **)dummy;
 *XGC= (double *)&ScilabGCXfig;
}
void C2F(setscilabxgcXfig)(integer *v1, integer *v2, integer *v3, integer *v4)
{}
/* NG end */


/* 2 routines used only by a call to xinitfromscreen to perform the colormap selection */
/* directly from the screen */

void C2F(initgraphicfromscreenXfig)(char *string, integer *v2, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{ 
  static integer EntryCounter = 0;
  integer fnum;
  *v3 = 0;
  if (EntryCounter >= 1) C2F(xendgraphicXfig)();
  file=fopen(string,"w");
  if (file == 0) 
    {
      /*sciprint("Can't open file %s, I'll use stdout\r\n",string1);*/
      file = stdout;
      *v3 = 1;
      return;
    }
  if (EntryCounter == 0)
    { 
      fnum=0;      C2F(loadfamilyXfig)("Courier",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=1;      C2F(loadfamilyXfig)("Symbol",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=2;      C2F(loadfamilyXfig)("Times-Roman",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
      fnum=3;      C2F(loadfamilyXfig)("Times-Italic",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=4;      C2F(loadfamilyXfig)("Times-Bold",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0);
      fnum=5;      C2F(loadfamilyXfig)("Times-BoldItalic",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=6;      C2F(loadfamilyXfig)("Helvetica",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=7;      C2F(loadfamilyXfig)("Helvetica-Oblique",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=8;      C2F(loadfamilyXfig)("Helvetica-Bold",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
      fnum=9;      C2F(loadfamilyXfig)("Helvetica-BoldOblique",&fnum,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0); 
    }
  C2F(FileInitFromScreenXfig)();
  ScilabGCXfig.CurWindow =EntryCounter;
  EntryCounter =EntryCounter +1;
}

static void C2F(FileInitFromScreenXfig)(void)
{
  int m;
  integer x[2],verbose,narg;
  verbose = 0; 
  C2F(getwindowdimXfig)(&verbose,x,&narg,vdouble);
  FPRINTF((file,"#FIG 3.1\nPortrait\nCenter\nInches\n1200 2\n"));
  ScilabGCXfig_is_initialized = TRUE; /* add the flag ScilabGCXfig_is_initialized to test if xinit has been called */
  C2F(InitScilabGCXfig)(PI0,PI0,PI0,PI0);
  if (  CheckColormap(&m) == 1) 
    { 
      int i;
      float r,g,b;
      ScilabGCXfig.Numcolors = m;
      ScilabGCXfig.NumForeground = m;
      ScilabGCXfig.NumBackground = m + 1;

      if (ScilabGCXfig.CurColorStatus == 1) 
        {
          ScilabGCXfig.IDLastPattern = ScilabGCXfig.Numcolors - 1;
        }
      for ( i=0; i < m ; i++)
        {
          unsigned short ur,ug,ub;
          get_r(i,&r);
          get_g(i,&g);
          get_b(i,&b);
          ur = (unsigned short) (65535.0*r);
          ug = (unsigned short) (65535.0*g);
          ub = (unsigned short) (65535.0*b); 
          ur = ur >> 8 ;
          ug = ug >> 8 ;        
          ub = ub >> 8 ; 
          FPRINTF((file,"0 %d #%02x%02x%02x\n",32+i,ur,ug,ub));
        }
      FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m,0,0,0));
      FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m+1,255,255,255));
    }
  else 
    {
      m = DEFAULTNUMCOLORS;
      ScilabGCXfig.Numcolors = m;
      ScilabGCXfig.IDLastPattern = m - 1;
      ScilabGCXfig.NumForeground = m;
      ScilabGCXfig.NumBackground = m + 1;
      FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m,0,0,0));
      FPRINTF((file,"0 %d #%02x%02x%02x \n",32+m+1,255,255,255));
    }

  FPRINTF((file,"2 2 0 0 -1 -1 0 0 -1 0.000 0 0 0 0 0 5\n"));
  FPRINTF((file," %d %d %d %d %d %d %d %d %d %d \n",
          0,0,(int)x[0],0,(int)x[0],(int)x[1],0,(int)x[1],0,0));
}

---