Axes.c File Reference

#include <math.h>
#include <string.h>
#include <stdio.h>
#include "math_graphics.h"
#include "PloEch.h"
#include "Axes.h"
#include "DestroyObjects.h"
#include "DrawObjects.h"
#include "InitObjects.h"
#include "Xcall1.h"
#include "SetProperty.h"
#include "handleDrawing/drawTextEntity.h"
#include "sciprint.h"
#include "Format.h"
#include "Plo3d.h"
#include "axesScale.h"
#include "CurrentObjectsManagement.h"
#include "MALLOC.h"
#include "GetProperty.h"

Include dependency graph for Axes.c:

Go to the source code of this file.

Functions
static double x_convert	__PARAMS ((char xy_type, double x[], int i))
static void	axesplot (char *, sciPointObj *)
static int	SciAxisNew (char pos, sciPointObj *psubwin, double xy, int fontsize, int fontstyle, int textcolor, int ticscolor, int seg)
static void	DrawXTics (char pos, sciPointObj *psubwin, double xy, char *c_format, int *fontid, int textcolor, int ticscolor, int color_kp, int *logrect, int smallersize)
static void	DrawYTics (char pos, sciPointObj *psubwin, double xy, char *c_format, int *fontid, int textcolor, int ticscolor, int color_kp, int *logrect, int smallersize)
static int	XDrawAxisLine (double xminval, double xmaxval, double xy, int ticscolor, int color_kp)
static int	YDrawAxisLine (double yminval, double ymaxval, double xy, int ticscolor, int color_kp)
static void	FindXYMinMaxAccordingTL (sciPointObj *psubwin, double *xminval, double *yminval, double *xmaxval, double *ymaxval)
static int	DrawXSubTics (char pos, sciPointObj *psubwin, double xy, int ticscolor, int color_kp)
static int	DrawYSubTics (char pos, sciPointObj *psubwin, double xy, int ticscolor, int color_kp)
static int	DrawXGrid (sciPointObj *psubwin)
static int	DrawYGrid (sciPointObj *psubwin)
static void	YGradPosition (sciPointObj *psubwin, int xx, int rect2)
static void	XGradPosition (sciPointObj *psubwin, int yy, int rect3)
int	SciDrawLines (char pos, sciPointObj *psubwin, double xy, int textcolor, int ticscolor)
void	axis_draw (char strflag[])
void	axis_draw2 (char strflag[])
void	DrawAxesBackground (void)
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)
static double	x_convert (char xy_type, double *x, int i)
static double	y_convert (char xy_type, double *y, int i)
void	clearSubWin (sciPointObj *pSubWin)
void	reinitSubWin (sciPointObj *pSubWin)
void	initSubWinAngles (sciPointObj *pSubWin)
void	initSubWinSize (sciPointObj *pSubWin)
void	initSubWinBounds (sciPointObj *pSubWin)
BOOL	checkRedrawing (void)
BOOL	CheckDisplay (double fact_h, double fact_w, char logflag, char *foo, int *posi, int *fontid, int *old_rect)
BOOL	IsInsideRectangle (int *rect, int *point)
void	getTicksLabelBox (double fact_h, double fact_w, char *label, int pos[2], int fontId[2], char logflag, int bbox[4], BOOL changeFont)
BOOL	checkXAxes2dTics (sciPointObj *psubwin, char side, double y, char *cFormat, int fontId[2], int smallersize)
BOOL	checkYAxes2dTics (sciPointObj *psubwin, char side, double x, char *cFormat, int fontId[2], int smallersize)
void	updateXaxesTics (sciPointObj *psubwin, char side, double y, int fontId[2], int smallersize)
void	updateYaxesTics (sciPointObj *psubwin, char side, double x, int fontId[2], int smallersize)
void	removeBadTicks (double *ticks, BOOL *removedTicks, int *nbTicks)
void	removeIndex (double *changedArray, int size, int ind)
void	findFormat (sciPointObj *pSubWin, char formatX[5], char formatY[5])
void	updateSubWinScale (sciPointObj *pSubWin)
void	updateScaleIfRequired (sciPointObj *pSubWin)
void	drawAxesGrid (sciPointObj *psubwin)
void	axis_3ddraw (sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD)
void	triedre (sciPointObj *pobj, double *xbox, double *ybox, double *zbox, integer *InsideU, integer *InsideD)
void	rebuild_strflag (sciPointObj *psubwin, char *STRFLAG)
int	labels2D_draw (sciPointObj *psubwin)
void	DrawAxis (double xbox[8], double ybox[8], integer Indices[4], integer style)
int	Axes3dStrings2 (integer *ixbox, integer *iybox, integer *xind)

---

Function Documentation

static double x_convert __PARAMS

(

(char xy_type, double x[], int i)

)

[static]

int Axes3dStrings2	(	integer *	ixbox,
		integer *	iybox,
		integer *	xind
	)

Author:

F.Leray 18.10.04

le cot\'e gauche ( c'est tjrs un axe des Z

bottom right side

bottom left side

Definition at line 3202 of file Axes.c.

References C2F, Cscale, dr(), i, iflag, j, L, sciSubWindow::mon_title, NULL, PD0, PI0, pLABEL_FEATURE, pSUBWIN_FEATURE, SCI_SUBWIN, sciGetCurrentSubWin(), sciGetEntityType(), sciGetFontDeciWidth(), sciGetFontForeground(), sciGetFontStyle(), sciGetForeground(), sciGetVisibility(), sciprint(), sciSetFontOrientation(), size, wcscalelist::WIRect1, x, and y.

{
  integer verbose=0,narg,xz[2],fontid[2],fontsize_kp,color_kp,size;
  integer iof,barlengthx = 0,barlengthy = 0, posi[2]; 
  integer rect[4],flag=0,x=0,y=0;
  double ang=0.0, bbox[6];
  int fontsize=-1,textcolor=-1,ticscolor=-1;
  int fontstyle=0; /* F.Leray 08.04.04 */
  sciPointObj *psubwin = NULL;
  sciSubWindow * ppsubwin = NULL;
  int ns=2,iflag=0,gstyle,gridStyle=2,dash[6];
  double xx[4],yy[4],zz[4],vxx1,vyy1,vzz1;
  integer i,xm,ym,vx[2],vy[2],xg[2],yg[2],j;
  integer fontid_old[2], textcolor_old;

  int lastzindex = 0, lastxindex = 0, lastyindex = 0;
  double xminval, yminval, zminval, xmaxval, ymaxval, zmaxval;
  int nbtics = 0;
  int nbsubtics = 0;

  int logrect[4], XX = 0, YY = 0; /* see below */ /* ah ouais ou ca ? */
  double angle=0.0;

  int constOffset[2] ; /* displacment of labels from the axes segments. */
  int maxTicksLabelSize[2] ; /* for each axis the maximum size of ticks label */


  psubwin= sciGetCurrentSubWin();
  ppsubwin = pSUBWIN_FEATURE (psubwin);

  xz[0] = Cscale.WIRect1[2] ;
  xz[1] = Cscale.WIRect1[2] ;
  iof = (xz[0]+xz[1])/50;

  ticscolor = sciGetForeground(psubwin);
  textcolor=sciGetFontForeground(psubwin);

  fontsize=sciGetFontDeciWidth(psubwin)/100;
  fontstyle=sciGetFontStyle(psubwin);

  if(sciGetEntityType (psubwin) != SCI_SUBWIN) { 
    sciprint("Impossible case\n");
    return 0;
  }


  bbox[0] =  xminval = pSUBWIN_FEATURE (psubwin)->FRect[0]; /*xmin*/
  bbox[1] =  xmaxval = pSUBWIN_FEATURE (psubwin)->FRect[2]; /*xmax*/
  bbox[2] =  yminval = pSUBWIN_FEATURE (psubwin)->FRect[1]; /*ymin*/
  bbox[3] =  ymaxval = pSUBWIN_FEATURE (psubwin)->FRect[3]; /*ymax*/ 
  bbox[4] =  zminval = pSUBWIN_FEATURE (psubwin)->FRect[4]; /*zmin*/
  bbox[5] =  zmaxval = pSUBWIN_FEATURE (psubwin)->FRect[5]; /*zmax*/

  C2F(dr)("xget","font",&verbose,fontid,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

  fontid[0]= fontstyle;
  fontsize_kp = fontid[1] ;
  if( fontsize == -1 ){ 
    fontid[1]= 1;
    C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }
  else {
    fontid[1] = fontsize ;
    C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }
  if ( textcolor != -1 || ticscolor != -1 ) 
    C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);    

  for (i=0; i<3 ; i++) {
    xx[i]=pSUBWIN_FEATURE (psubwin)->axes.xlim[i];
    yy[i]=pSUBWIN_FEATURE (psubwin)->axes.ylim[i];
    zz[i]=pSUBWIN_FEATURE (psubwin)->axes.zlim[i];
  } 

  /* main title */ /* We fix the title always at the top */
  rect[0]= Cscale.WIRect1[0] ;
  rect[1]= Cscale.WIRect1[1] ;
  rect[2]= Cscale.WIRect1[2] ;
  rect[3]= Cscale.WIRect1[3]/6 ;
  textcolor_old = textcolor;
  fontid_old[0] = fontid[0];
  fontid_old[1] = fontid[1];

  constOffset[0] = Cscale.WIRect1[2] / 50 + 1 ;
  constOffset[1] = Cscale.WIRect1[3] / 25 + 1 ;

  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 )
    {
      /* same as in 2d */
      int segmentStart[2] = { rect[0] + rect[2], rect[1] } ;
      int segmentEnd[2]   = { rect[0]          , rect[1] } ;
      computeLabelAutoPos( ppsubwin->mon_title, segmentStart, segmentEnd, constOffset ) ;
    }
    /* draw the label */
    drawTextEntity( ppLabel->text ) ;
  }

  textcolor = textcolor_old;
  fontid[0] = fontid_old[0];
  fontid[1] = fontid_old[1];

  size = xz[0]>=xz[1] ? (integer) (xz[1]/50.0) : (integer) (xz[0]/50.0); 

  /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
  C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   

  /********************************************/
  /* draw the axis line if axes_visible is on */
  /********************************************/
  {
    int x2[5] ;
    int two = 2 ;
    int one = 1 ;
    int verbose2 = 0 ;
    int dash2[6] ;
    int pat ;
    int narg2 ;
    x2[0] = sciGetForeground (psubwin);
    x2[2] = sciGetLineWidth (psubwin) ;
    x2[3] = sciGetLineStyle (psubwin);
    x2[4] = 0;
    C2F(dr)("xget","line style",&verbose2,dash2,&narg2,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
    C2F(dr)("xget","pattern",&verbose2,&pat,&narg2,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    C2F (dr) ("xset", "dashes", x2, x2, x2+4, x2+4, x2+4,PI0,PD0,PD0,PD0,PD0, 5L, 6L);
    C2F (dr) ("xset","foreground",x2,x2,x2+4,x2+4,x2+4,PI0,PD0,PD0,PD0,PD0,5L,4096); /* F.Leray 05.03.04 Useless too*/
    C2F (dr) ("xset","thickness",x2+2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    C2F (dr) ("xset", "line style", x2+3,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    if ( ppsubwin->axes.axes_visible[2] )
    {
      /* draw the line of the axis like in 2d */
      /* the two bounds are (ixbox[2],iybox[2]) and (ixbox[2],iybox[2]) */
      C2F(dr)("xpolys","v",&(ixbox[2]),&(iybox[2]),x2,&one,&two, PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
    if ( ( xind[4]+xind[5] == 3) || ( xind[4]+xind[5] == 11 ) )
    {
      /* i copy this test but I don't know what it mean... jb Silvy 03/2006 */
      if ( ppsubwin->axes.axes_visible[1] )
      {
        /* draw the line of the axis like in 2d */
        /* the two bounds are (ixbox[3],iybox[3]) and (ixbox[3],iybox[3]) */
        C2F(dr)("xpolys","v",&(ixbox[3]),&(iybox[3]),x2,&one,&two, PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
      if ( ppsubwin->axes.axes_visible[0] )
      {
        /* draw the line of the axis like in 2d */
        /* the two bounds are (ixbox[4],iybox[4]) and (ixbox[4],iybox[4]) */
        C2F(dr)("xpolys","v",&(ixbox[4]),&(iybox[4]),x2,&one,&two, PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
    }
    else
    {
      if ( ppsubwin->axes.axes_visible[1] )
      {
        /* draw the line of the axis like in 2d */
        /* the two bounds are (ixbox[3],iybox[3]) and (ixbox[3],iybox[3]) */
        C2F(dr)("xpolys","v",&(ixbox[4]),&(iybox[4]),x2,&one,&two, PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
      if ( ppsubwin->axes.axes_visible[0] )
      {
        /* draw the line of the axis like in 2d */
        /* the two bounds are (ixbox[4],iybox[4]) and (ixbox[4],iybox[4]) */
        C2F(dr)("xpolys","v",&(ixbox[3]),&(iybox[3]),x2,&one,&two, PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
    }
    C2F(dr)("xset","pattern",&pat,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    C2F(dr)("xset","line style",dash2,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }  

  /********************/
  /*** le z scaling ***/ /* DISPLAY Z graduations */
  /********************/


  if (pSUBWIN_FEATURE (psubwin)->project[2]==1)
  {
    double fx,fy,fz; 
    char c_format[5] ;

    integer Ticsdir[2];
    Ticsdir[0]=ixbox[3]-ixbox[4]; /* <=> en pixel direction/vecteur non norme(e)s des tics en x */
    Ticsdir[1]=iybox[3]-iybox[4]; /* <=> idem pour y */
    /* NB: for a default plot3d (simply calling plot3d in siclab console) */
    /* Ticsdir[0] & Ticsdir[1] are negative : we do min - max here... */

    BBoxToval(&fx,&fy,&fz,xind[3],bbox); /* xind[3] <=> en bas a gauche <=> zmin */
    x=ixbox[2]-(xz[0]+xz[1])/20;
    y=(iybox[3]+iybox[2])/2;

    /*       NumberFormat(str,((integer) zz[0]),((integer) zz[2])); */


    if( !ppsubwin->axes.auto_ticks[2] )
    {
      /* we display the z tics specified by the user*/
      nbtics = ppsubwin->axes.u_nzgrads;
      nbsubtics = ppsubwin->axes.nbsubtics[2];

      maxTicksLabelSize[0] = 0 ;
      maxTicksLabelSize[1] = 0 ;

      for(i=0;i<nbtics;i++)
      {
        char *foo = ppsubwin->axes.u_zlabels[i]; 
        double ztmp = ppsubwin->axes.u_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... */
        }


        /***************************************************************/
        /************************* COMMON PART *************************/
        /***************************************************************/

        if( ppsubwin->axes.reverse[2] )
        {
          ztmp = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp);
        }

        ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&ztmp);


        vx[0]=xm;vy[0]=ym;

        barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
        barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
        vx[1]=vx[0]+barlengthx;
        vy[1]=vy[0]+barlengthy;

        /* foo is set above with sprintf(foo,c_format,xtmp); */

        C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */

        /* get the size of ticks label */
        C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
        maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
        maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;


        posi[0] = inint( xm+2*barlengthx - rect[2]); 
        posi[1]=inint( ym + 2*barlengthy + rect[3]/2);


        if(ppsubwin->axes.axes_visible[2] == TRUE){
          C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
          C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
        }
        /* grid to put here */
        if ( ppsubwin->grid[2] > -1 && ppsubwin->axes.axes_visible[2] )
        {
          gstyle = pSUBWIN_FEATURE (psubwin)->grid[2];

          if((ppsubwin->logflags[2] =='l') && (i != nbtics-1))
          {
            double tmp[2];
            double pas=0;
            double * tmp_log_grads = (double *) NULL;


            double * grads = ppsubwin->axes.u_zgrads;

            tmp[0] = exp10(grads[i]);
            tmp[1] = exp10(grads[i+1]);
            pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

            if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
              sciprint("Error allocating tmp_log_grads\n");
              return -1;
            }

            for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

            for(j=0;j<nbsubtics;j++)
            {
              vzz1 = tmp_log_grads[j];

              if(vzz1<=zminval || vzz1>=zmaxval) continue;       

              if(ppsubwin->axes.reverse[2] == TRUE)
                vzz1 = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],vzz1);

              ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1);

              /*  if ((ym != iybox[3]) && (ym != iybox[2])) */
              /*                            { */
              C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]= ixbox[3];yg[0]= ym;
              if (Ishidden(psubwin))
              {  xg[1]=ixbox[4];  yg[1]= iybox[4]- iybox[3]+ym;}
              else
              {xg[1]=ixbox[1];  yg[1]= iybox[1]- iybox[2]+ym;}
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]=xg[1];  ; xg[1] =ixbox[0];
              yg[0]=yg[1]; yg[1]= ym- iybox[3]+ iybox[5];
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              /*   } */
            }
            FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
          }
          else
          { 
            if(ztmp>zminval && ztmp<zmaxval) 
            {
              C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]= ixbox[3];yg[0]= ym;
              if (Ishidden(psubwin))
              {  xg[1]=ixbox[4];  yg[1]= iybox[4]- iybox[3]+ym;}
              else
              {xg[1]=ixbox[1];  yg[1]= iybox[1]- iybox[2]+ym;}
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]=xg[1];  ; xg[1] =ixbox[0];
              yg[0]=yg[1]; yg[1]= ym- iybox[3]+ iybox[5];
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
          }
        }

        /* and subtics */
        if(i != nbtics-1)
        {
          if(ppsubwin->logflags[2] =='l')
          {
            double tmp[2];
            double pas=0;
            double * tmp_log_grads = (double *) NULL;


            double * grads = ppsubwin->axes.u_zgrads;

            tmp[0] = exp10(grads[i]);
            tmp[1] = exp10(grads[i+1]);
            pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

            if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
              sciprint("Error allocating tmp_log_grads\n");
              return -1;
            }

            for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

            for(j=0;j<nbsubtics;j++)
            {
              vzz1 = tmp_log_grads[j];

              if(vzz1<zminval || vzz1>zmaxval) continue;

              if(ppsubwin->axes.reverse[2] == TRUE)
                vzz1 = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],vzz1);

              ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1);

              vx[0]=xm;vy[0]=ym;
              vx[1]= (integer) (vx[0]+barlengthx/2.0);
              vy[1]= (integer) (vy[0]+barlengthy/2.0);

              if(ppsubwin->axes.axes_visible[2] == TRUE)
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
          } /* end NEW */
          else
          {
            double xtmp = ppsubwin->axes.u_zgrads[i];
            double dx = (ppsubwin->axes.u_zgrads[i+1] - ppsubwin->axes.u_zgrads[i]) / nbsubtics;
            for(j=0;j<nbsubtics;j++)
            {
              vzz1=xtmp+dx*j;

              if(vzz1<zminval || vzz1>zmaxval) continue;         

              if(ppsubwin->axes.reverse[2] == TRUE)
                vzz1 = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],vzz1);

              ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1);
              /*                      trans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1); */


              vx[0]=xm;vy[0]=ym;
              vx[1]= (integer) (vx[0]+barlengthx/2.0);
              vy[1]= (integer) (vy[0]+barlengthy/2.0);

              if(ppsubwin->axes.axes_visible[2] == TRUE)
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
          } 
        }

        /***************************************************************/
        /************************* END OF COMMON PART ******************/
        /***************************************************************/
      }
    }
    else /* we display the computed tics */
    {
      AdaptGraduationsOnZ(x,y,size,Ticsdir,fontid,psubwin,zminval,zmaxval,fx,fy,0.);

      lastzindex = ppsubwin->axes.nzgrads - 1;

      if(lastzindex == 0)
        ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.zgrads[0]));
      else
        ChoixFormatE(c_format,
        ppsubwin->axes.zgrads[0],
        ppsubwin->axes.zgrads[lastzindex],
        ((ppsubwin->axes.zgrads[lastzindex])-(ppsubwin->axes.zgrads[0]))/(lastzindex));

      nbtics = ppsubwin->axes.nzgrads;
      nbsubtics = ppsubwin->axes.nbsubtics[2];

      maxTicksLabelSize[0] = 0 ;
      maxTicksLabelSize[1] = 0 ;

      for(i=0;i<nbtics;i++)
      {
        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);

        /***************************************************************/
        /************************* COMMON PART *************************/
        /***************************************************************/
        if(ppsubwin->axes.reverse[2] == TRUE)
          ztmp = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],ztmp);

        ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&ztmp);

        /*            trans3d(psubwin,1,&xm,&ym,&fx,&fy,&ztmp); */


        vx[0]=xm;vy[0]=ym;

        barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
        barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
        vx[1]=vx[0]+barlengthx;
        vy[1]=vy[0]+barlengthy;

        /* foo is set above with sprintf(foo,c_format,xtmp); */

        C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */

        /* get the size of ticks label */
        C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
        maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
        maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;

        posi[0] = inint( xm+2*barlengthx - rect[2]); 
        posi[1]=inint( ym + 2*barlengthy + rect[3]/2);

        if(ppsubwin->axes.axes_visible[2] == TRUE){
          C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          if ( ppsubwin->logflags[2] == 'l' )
          {
            int smallersize = fontid[1]-2;
            int old_rect10[4];
            /*              char str[2] = "xv"; */
            int posi10[2];

            posi10[0] = posi[0] - logrect[2];
            posi10[1] = posi[1] + logrect[3];

            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xstring","10",(&posi10[0]),(&posi10[1]),PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);

            C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

            posi[0] = old_rect10[0] + old_rect10[2];
            posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);

            C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

            /* put back the current fontid */
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          else{
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
          }

          C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
          C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
        }
        /* grid to put here */
        if ( ppsubwin->grid[2] > -1 && ppsubwin->axes.axes_visible[2] )
        {
          gstyle = pSUBWIN_FEATURE (psubwin)->grid[2];

          if((ppsubwin->logflags[2] =='l') && (i != nbtics-1))
          {
            double tmp[2];
            double pas=0;
            double * tmp_log_grads = (double *) NULL;


            double * grads = ppsubwin->axes.zgrads;

            tmp[0] = exp10(grads[i]);
            tmp[1] = exp10(grads[i+1]);
            pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

            if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
              sciprint("Error allocating tmp_log_grads\n");
              return -1;
            }

            for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

            for(j=0;j<nbsubtics;j++)
            {
              vzz1 = tmp_log_grads[j];

              if(vzz1<=zminval || vzz1>=zmaxval) continue;       

              if(ppsubwin->axes.reverse[2] == TRUE)
                vzz1 = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],vzz1);

              ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1);

              /*  if ((ym != iybox[3]) && (ym != iybox[2])) */
              /*                            { */
              C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]= ixbox[3];yg[0]= ym;
              if (Ishidden(psubwin))
              {  xg[1]=ixbox[4];  yg[1]= iybox[4]- iybox[3]+ym;}
              else
              {xg[1]=ixbox[1];  yg[1]= iybox[1]- iybox[2]+ym;}
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]=xg[1];  ; xg[1] =ixbox[0];
              yg[0]=yg[1]; yg[1]= ym- iybox[3]+ iybox[5];
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              /*   } */
            }
            FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
          }
          else
          {
            if(ztmp>zminval && ztmp<zmaxval) 
            {
              C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]= ixbox[3];yg[0]= ym;
              if (Ishidden(psubwin))
              {  xg[1]=ixbox[4];  yg[1]= iybox[4]- iybox[3]+ym;}
              else
              {xg[1]=ixbox[1];  yg[1]= iybox[1]- iybox[2]+ym;}
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              xg[0]=xg[1];  ; xg[1] =ixbox[0];
              yg[0]=yg[1]; yg[1]= ym- iybox[3]+ iybox[5];
              C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
          }
        }

        /* and subtics */
        if(i != nbtics-1)
        {
          if(ppsubwin->logflags[2] =='l')
          {
            double tmp[2];
            double pas=0;
            double * tmp_log_grads = (double *) NULL;


            double * grads = ppsubwin->axes.zgrads;

            tmp[0] = exp10(grads[i]);
            tmp[1] = exp10(grads[i+1]);
            pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

            if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
              sciprint("Error allocating tmp_log_grads\n");
              return -1;
            }

            for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

            for(j=0;j<nbsubtics;j++)
            {
              vzz1 = tmp_log_grads[j];

              if(vzz1<zminval || vzz1>zmaxval) continue;

              if(ppsubwin->axes.reverse[2] == TRUE)
                vzz1 = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],vzz1);

              ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1);

              vx[0]=xm;vy[0]=ym;
              vx[1]= (integer) (vx[0]+barlengthx/2.0);
              vy[1]= (integer) (vy[0]+barlengthy/2.0);

              if(ppsubwin->axes.axes_visible[2] == TRUE)
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
          } /* end NEW */
          else
          {
            double ztmp2 = ppsubwin->axes.zgrads[i];
            double dz = (ppsubwin->axes.zgrads[i+1] - ppsubwin->axes.zgrads[i]) / nbsubtics;
            for(j=0;j<nbsubtics;j++)
            {
              vzz1=ztmp2+dz*j;

              if(vzz1<zminval || vzz1>zmaxval) continue;

              if(ppsubwin->axes.reverse[2] == TRUE)
                vzz1 = InvAxis(ppsubwin->FRect[4],ppsubwin->FRect[5],vzz1);

              ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1);
              /*                      trans3d(psubwin,1,&xm,&ym,&fx,&fy,&vzz1); */


              vx[0]=xm;vy[0]=ym;
              vx[1]= (integer) (vx[0]+barlengthx/2.0);
              vy[1]= (integer) (vy[0]+barlengthy/2.0);

              if(ppsubwin->axes.axes_visible[2] == TRUE)
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
          }
        }
        /***************************************************************/
        /************************* END OF COMMON PART ******************/
        /***************************************************************/

      }
    }
  }

  if ( sciGetVisibility(ppsubwin->mon_z_label) )
  {
    /* draw z label */
    sciLabel * ppLabel = pLABEL_FEATURE(ppsubwin->mon_z_label) ;

    if ( ppLabel->auto_rotation )
    {
      /* mult by 10 because */
      sciSetFontOrientation(ppsubwin->mon_z_label, 270 * 10 ) ;
    }

    if( ppLabel->auto_position )
    {

      int segmentStart[2] = { ixbox[2], iybox[2] } ;
      int segmentEnd[2]   = { ixbox[3], iybox[3] } ;

      /* add the bar size and ticks label size to the offset */
      int offset[2] = { constOffset[0] + maxTicksLabelSize[0] + abs( barlengthx ), 
        constOffset[1] + maxTicksLabelSize[1] + abs( barlengthy )  } ;
      computeLabelAutoPos( ppsubwin->mon_z_label, segmentStart, segmentEnd, offset ) ;
    }
    /* a trick to force the display with 2d scale */
    drawTextEntity( ppLabel->text ) ;

  }


  /***********************/ 
  /*** le  x-y scaling ***/ /* DISPLAY x or y graduations */
  /***********************/


  if (( xind[4]+xind[5] == 3) || ( xind[4]+xind[5] == 11))
  {
    if (pSUBWIN_FEATURE (psubwin)->project[0]==1) /* x HERE */
    {
      double fx,fy,fz;
      char c_format[5];

      integer Ticsdir[2]; 
      Ticsdir[0]=ixbox[4]-ixbox[3];
      Ticsdir[1]=iybox[4]-iybox[3];
      BBoxToval(&fx,&fy,&fz,xind[4],bbox);
      x=inint((ixbox[4]+ixbox[5])/2+1.5*rect[2] +iof);
      y=inint(((2/3.0)*iybox[4]+(1/3.0)*iybox[5])+1.5*rect[3]+iof);

      if( !ppsubwin->axes.auto_ticks[0] )
      {
        /* we display the x tics specified by the user*/
        nbtics = ppsubwin->axes.u_nxgrads;
        nbsubtics = ppsubwin->axes.nbsubtics[0];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          char *foo = ppsubwin->axes.u_xlabels[i]; 
          double xtmp = ppsubwin->axes.u_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... */
          }

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          if(ppsubwin->axes.reverse[0] == TRUE)
            xtmp = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz);
          /*   trans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz); */


          vx[0]=xm;vy[0]=ym;

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */

          /* get the size of the icks label */
          C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;


          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( ppsubwin->axes.axes_visible[0] )
          {    
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[0] > -1 && ppsubwin->axes.axes_visible[0] )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[0];

            if((ppsubwin->logflags[0] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<=xminval || vxx1>=xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                /*  if ((xm != ixbox[5]) && (xm != ixbox[4])) */
                /*                              {  */
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin)) 
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 

                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(xtmp>xminval && xtmp<xmaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin)) 
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[0] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }

              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            } /* end NEW */
            else
            {
              double xtmp2 = ppsubwin->axes.u_xgrads[i];
              double dx = (ppsubwin->axes.u_xgrads[i+1] - ppsubwin->axes.u_xgrads[i]) / nbsubtics;

              for (j=1;j<nbsubtics;j++)
              {  
                vxx1=xtmp2+dx*j;

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);
                /*                        trans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz); */


                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)   
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }
          /***************************************************************/
          /************************* END OF COMMON PART ******************/
          /***************************************************************/

        }
      }
      else /* we display the computed tics */
      {
        AdaptGraduationsOnXBottomRight(iof,x,y,size,Ticsdir,fontid,psubwin,xminval,xmaxval,0.,fy,fz);

        lastxindex = ppsubwin->axes.nxgrads - 1;

        if(lastxindex == 0)
        {
          ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.xgrads[0]));
        }
        else
        {
          ChoixFormatE(c_format,
            ppsubwin->axes.xgrads[0],
            ppsubwin->axes.xgrads[lastxindex],
            ((ppsubwin->axes.xgrads[lastxindex])-(ppsubwin->axes.xgrads[0]))/(lastxindex));
        }

        nbtics = ppsubwin->axes.nxgrads;
        nbsubtics = ppsubwin->axes.nbsubtics[0];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          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);

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/


          /* F.Leray 03.11.04 Test if log scale to perform a : exp10(x) because trans3d will */
          /* re-do a log10() (that is needed for data computations) */

          if( ppsubwin->axes.reverse[0] )
          {
            xtmp = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp);
          }

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz);

          vx[0]=xm;vy[0]=ym; 

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */

          /* get the size of ticks label */
          C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;

          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( ppsubwin->axes.axes_visible[0] )
          {
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            if ( ppsubwin->logflags[0] == 'l' )
            {
              int smallersize = fontid[1]-2;
              int old_rect10[4];
              int posi10[2];

              posi10[0] = posi[0] - logrect[2];
              posi10[1] = posi[1] + logrect[3];

              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring","10",(&posi10[0]),(&posi10[1]),PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);

              C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

              posi[0] = old_rect10[0] + old_rect10[2];
              posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);

              C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

              /* put back the current fontid */
              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            else
            {
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
            }       
            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[0] > -1 && ppsubwin->axes.axes_visible[0]  )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[0];

            if((ppsubwin->logflags[0] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++)
              {
                tmp_log_grads[j] = log10( tmp[0] + (j) * pas ) ;
              }

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<=xminval || vxx1>=xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                /*  if ((xm != ixbox[5]) && (xm != ixbox[4])) */
                /*                              {  */
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin)) 
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 

                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(xtmp>xminval && xtmp<xmaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin)) 
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }   
          }

          /* and subtics */
          if(i != nbtics-1) /* F.Leray NEW 03.11.04 */
          {

            if(ppsubwin->logflags[0] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if( ppsubwin->axes.axes_visible[0] )
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }

              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            } /* end NEW */
            else
            {
              double xtmp2 = ppsubwin->axes.xgrads[i];
              double dx = (ppsubwin->axes.xgrads[i+1] - ppsubwin->axes.xgrads[i]) / nbsubtics;

              for (j=1;j<nbsubtics;j++)
              {  
                vxx1=xtmp2+dx*j;

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }

          /***************************************************************/
          /************************* END OF COMMON PART ******************/
          /***************************************************************/

        }
      }
    }
    if ( sciGetVisibility(ppsubwin->mon_x_label) )
    {
      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] = { ixbox[4], iybox[4] } ;
        int segmentEnd[2]   = { ixbox[5], iybox[5] } ;

        /* add the bar size and ticks label size to the offset */
        int offset[2] = { constOffset[0] + maxTicksLabelSize[0] + abs( barlengthx ), 
          constOffset[1] + maxTicksLabelSize[1] + abs( barlengthy )  } ;
        computeLabelAutoPos( ppsubwin->mon_x_label, segmentStart, segmentEnd, offset ) ;
      }
      /* a trick to force the display with 2d scale */
      drawTextEntity( ppLabel->text ) ;

    }
  }
  else
  {

    if ( pSUBWIN_FEATURE (psubwin)->project[1]==1) /* y is HERE */
    {
      double fx,fy,fz; 
      char c_format[5];

      integer Ticsdir[2];
      Ticsdir[0]=ixbox[4]-ixbox[3];
      Ticsdir[1]=iybox[4]-iybox[3];
      BBoxToval(&fx,&fy,&fz,xind[4],bbox);

      x=inint((ixbox[4]+ixbox[5])/2+1.5*rect[2] +iof);
      y=inint(((2/3.0)*iybox[4]+(1/3.0)*iybox[5])+1.5*rect[3]+iof);

      if(ppsubwin->axes.auto_ticks[1] == FALSE)
      {
        /* we display the y tics specified by the user*/
        nbtics = ppsubwin->axes.u_nygrads;
        nbsubtics = ppsubwin->axes.nbsubtics[1];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          char *foo = ppsubwin->axes.u_ylabels[i]; 
          double ytmp = ppsubwin->axes.u_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... */
          }


          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          if(ppsubwin->axes.reverse[1] == TRUE)
            ytmp = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz);
          /*              trans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz); */



          vx[0]=xm;vy[0]=ym;

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          /*    NumberFormat(foo,((integer) (yy[0] + i*ceil((yy[1]-yy[0])/yy[3]))), */
          /*                         ((integer) yy[2])); */
          C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */

          /* get the size of the ticks */
          C2F(dr)("xstringl",foo,&x,&y,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;


          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 - rect[2]/2); */
            /*              posi[0] = inint( xm+2*barlengthx - rect[2]); */
            posi[0] = inint( xm+2*barlengthx);
            posi[1]=inint( ym + 2*barlengthy + rect[3]);}

          if(ppsubwin->axes.axes_visible[1] == TRUE){
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[1] > -1 && ppsubwin->axes.axes_visible[1] )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[1];

            if((ppsubwin->logflags[1] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<=yminval || vyy1>=ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                /*  if ((xm != ixbox[5]) && (xm != ixbox[4])) */
                /*                              {  */
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(ytmp>yminval && ytmp<ymaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[1] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;

            } /* end NEW */
            else
            {
              double ytmp2 = ppsubwin->axes.u_ygrads[i];
              double dy = (ppsubwin->axes.u_ygrads[i+1] - ppsubwin->axes.u_ygrads[i]) / nbsubtics;
              for(j=0;j<nbsubtics;j++)
              {
                vyy1=ytmp2+dy*j;

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }

          /***************************************************************/
          /************************* END OF COMMON PART ******************/
          /***************************************************************/
        }
      }
      else /* we display the computed tics */
      {
        AdaptGraduationsOnYBottomRight(iof,x,y,size,Ticsdir,fontid,psubwin,yminval,ymaxval,fx,0.,fz);

        lastyindex = ppsubwin->axes.nygrads - 1;

        if(lastyindex == 0)
          ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.ygrads[0]));
        else
          ChoixFormatE(c_format,
          ppsubwin->axes.ygrads[0],
          ppsubwin->axes.ygrads[lastyindex],
          ((ppsubwin->axes.ygrads[lastyindex])-(ppsubwin->axes.ygrads[0]))/(lastyindex));

        nbtics = ppsubwin->axes.nygrads;
        nbsubtics = ppsubwin->axes.nbsubtics[1];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          char foo[256]; 
          double ytmp2 = ppsubwin->axes.ygrads[i];

          if(ytmp2<yminval || ytmp2>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,ytmp2);

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          /* F.Leray 03.11.04 Test if log scale to perform a : exp10(x) because trans3d will */
          /* re-do a log10() (that is needed for data computations) */


          if(ppsubwin->axes.reverse[1] == TRUE)
            ytmp2 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp2);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&ytmp2,&fz);


          vx[0]=xm;vy[0]=ym;

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          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);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;

          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 - rect[2]/2); */
            /*              posi[0] = inint( xm+2*barlengthx - rect[2]); */
            posi[0] = inint( xm+2*barlengthx);
            posi[1]=inint( ym + 2*barlengthy + rect[3]);}

          if(ppsubwin->axes.axes_visible[1] == TRUE){
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            if ( ppsubwin->logflags[1] == 'l' )
            {
              int smallersize = fontid[1]-2;
              int old_rect10[4];
              /*                    char str[2] = "xv"; */
              int posi10[2];

              posi10[0] = posi[0] - logrect[2];
              posi10[1] = posi[1] + logrect[3];

              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring","10",(&posi10[0]),(&posi10[1]),PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);

              C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

              posi[0] = old_rect10[0] + old_rect10[2];
              posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);

              C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

              /* put back the current fontid */
              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            else
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }

          /* grid to put here */

          if ( ppsubwin->grid[1] > -1 && ppsubwin->axes.axes_visible[1] )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[1];

            if((ppsubwin->logflags[1] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<=yminval || vyy1>=ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                /*  if ((xm != ixbox[5]) && (xm != ixbox[4])) */
                /*                              {  */
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(ytmp2>yminval && ytmp2<ymaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[2] -iybox[3]+ym; }
                else
                {xg[1]= ixbox[3] - ixbox[4] +xm; yg[1]= iybox[3] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[3] - ixbox[4] +xm; 
                yg[1]=  iybox[2] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[1] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;

            } /* end NEW */
            else
            {
              double ytmp3 = ppsubwin->axes.ygrads[i];
              double dy = (ppsubwin->axes.ygrads[i+1] - ppsubwin->axes.ygrads[i]) / nbsubtics;
              for(j=0;j<nbsubtics;j++)
              {
                vyy1=ytmp3+dy*j;

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);
                /*   trans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz); */

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }
          /***************************************************************/
          /************************* END OF COMMON PART ******************/
          /***************************************************************/

        }
      }
    }
    if ( sciGetVisibility(ppsubwin->mon_y_label) )
    {
      sciLabel * ppLabel = pLABEL_FEATURE( ppsubwin->mon_y_label ) ;
      if( ppLabel->auto_rotation )
      {
        sciSetFontOrientation( ppsubwin->mon_y_label, 0 ) ;
      }

      if( ppLabel->auto_position )
      {

        int segmentStart[2] = { ixbox[4], iybox[4] } ;
        int segmentEnd[2]   = { ixbox[5], iybox[5] } ;

        /* add the bar size and ticks label size to the offset */
        int offset[2] = { constOffset[0] + maxTicksLabelSize[0] + abs( barlengthx ), 
          constOffset[1] + maxTicksLabelSize[1] + abs( barlengthy )  } ;
        computeLabelAutoPos( ppsubwin->mon_y_label, segmentStart, segmentEnd, offset ) ;
      }
      /* a trick to force the display with 2d scale */
      drawTextEntity( ppLabel->text ) ;

    }
  }



  /***********************/ 
  /*** le  x-y scaling ***/ /* DISPLAY x or y graduations */
  /***********************/

  if (( xind[3]+xind[4] == 3) || ( xind[3]+xind[4] == 11))
  {
    if (pSUBWIN_FEATURE (psubwin)->project[0]==1) /* x HERE */
    {
      double fx,fy,fz;
      char c_format[5];


      integer Ticsdir[2];
      Ticsdir[0]=ixbox[4]-ixbox[5];
      Ticsdir[1]=iybox[4]-iybox[5];
      BBoxToval(&fx,&fy,&fz,xind[3],bbox);

      x=inint((ixbox[3]+ixbox[4])/2.0 -rect[2] -iof);
      y=inint((1/3.0)*iybox[3]+(2/3.0)*iybox[4]+ iof+ 1.5*rect[3]); 

      if(ppsubwin->axes.auto_ticks[0] == FALSE)
      {
        /* we display the x tics specified by the user*/
        nbtics = ppsubwin->axes.u_nxgrads;
        nbsubtics = ppsubwin->axes.nbsubtics[0];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          char *foo = ppsubwin->axes.u_xlabels[i]; 
          double xtmp = ppsubwin->axes.u_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... */
          }

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          if(ppsubwin->axes.reverse[0] == TRUE)
            xtmp = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz);
          /*              trans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz); */


          vx[0]=xm;vy[0]=ym;

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          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);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;


          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-rect[2]); 
            posi[1]=inint( ym + 2*barlengthy + rect[3]);}

          if(ppsubwin->axes.axes_visible[0] == TRUE){
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[0] > -1 && ppsubwin->axes.axes_visible[0]  )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[0];

            if((ppsubwin->logflags[0] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<=xminval || vxx1>=xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                /*   if ((xm != ixbox[3]) && (xm != ixbox[4])) */
                /*                              {  */
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(xtmp>xminval && xtmp<xmaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[0] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }

              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            } /* end NEW */
            else
            {
              double xtmp2 = ppsubwin->axes.u_xgrads[i];
              double dx = (ppsubwin->axes.u_xgrads[i+1] - ppsubwin->axes.u_xgrads[i]) / nbsubtics;

              for (j=1;j<nbsubtics;j++)
              {  
                vxx1=xtmp2+dx*j;

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);
                /*                trans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz); */


                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }
          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/


        }

      }
      else /* we display the computed tics */
      {
        AdaptGraduationsOnXBottomLeft(iof,x,y,size,Ticsdir,fontid,psubwin,xminval,xmaxval,0.,fy,fz);

        lastxindex = ppsubwin->axes.nxgrads - 1;

        if(lastxindex == 0)
          ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.xgrads[0]));
        else
          ChoixFormatE(c_format,
          ppsubwin->axes.xgrads[0],
          ppsubwin->axes.xgrads[lastxindex],
          ((ppsubwin->axes.xgrads[lastxindex])-(ppsubwin->axes.xgrads[0]))/(lastxindex));

        nbtics = ppsubwin->axes.nxgrads;
        nbsubtics = ppsubwin->axes.nbsubtics[0];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          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);

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          if(ppsubwin->axes.reverse[0] == TRUE)
            xtmp = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],xtmp);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&xtmp,&fy,&fz);

          vx[0]=xm;vy[0]=ym;

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          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);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;

          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-rect[2]); 
            posi[1]=inint( ym + 2*barlengthy + rect[3]);}

          if(ppsubwin->axes.axes_visible[0] == TRUE){
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            if ( ppsubwin->logflags[0] == 'l' )
            {
              int smallersize = fontid[1]-2;
              int old_rect10[4];
              int posi10[2];

              posi10[0] = posi[0] - logrect[2];
              posi10[1] = posi[1] + logrect[3];

              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring","10",(&posi10[0]),(&posi10[1]),PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);

              C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

              posi[0] = old_rect10[0] + old_rect10[2];
              posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);

              C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

              /* put back the current fontid */
              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            else
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[0] > -1 && ppsubwin->axes.axes_visible[0] )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[0];

            if((ppsubwin->logflags[0] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<=xminval || vxx1>=xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);


                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  

              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(xtmp>xminval && xtmp<xmaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[0] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.xgrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vxx1 = tmp_log_grads[j];

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            } /* end NEW */
            else
            {
              double xtmp2 = ppsubwin->axes.xgrads[i];
              double dx = (ppsubwin->axes.xgrads[i+1] - ppsubwin->axes.xgrads[i]) / nbsubtics;

              for (j=1;j<nbsubtics;j++)
              {  
                vxx1=xtmp2+dx*j;

                if(vxx1<xminval || vxx1>xmaxval) continue;

                if(ppsubwin->axes.reverse[0] == TRUE)
                  vxx1 = InvAxis(ppsubwin->FRect[0],ppsubwin->FRect[2],vxx1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz);
                /*                trans3d(psubwin,1,&xm,&ym,&vxx1,&fy,&fz); */


                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[0] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }
          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

        }
      }
    }

    if ( sciGetVisibility(ppsubwin->mon_x_label) )
    { 

      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] = { ixbox[3], iybox[3] } ;
        int segmentEnd[2]   = { ixbox[4], iybox[4] } ;

        /* add the bar size and ticks label size to the offset */
        int offset[2] = { constOffset[0] + maxTicksLabelSize[0] + abs( barlengthx ), 
          constOffset[1] + maxTicksLabelSize[1] + abs( barlengthy )  } ;
        computeLabelAutoPos( ppsubwin->mon_x_label, segmentStart, segmentEnd, offset ) ;
      }
      /* a trick to force the display with 2d scale */
      drawTextEntity( ppLabel->text ) ;

    }
  }
  else 
  {
    if  (pSUBWIN_FEATURE (psubwin)->project[1]==1) /* y is HERE */
    {
      double fx,fy,fz;
      char c_format[5];

      integer Ticsdir[2];
      Ticsdir[0]=ixbox[4]-ixbox[5];
      Ticsdir[1]=iybox[4]-iybox[5];
      BBoxToval(&fx,&fy,&fz,xind[3],bbox);

      x=inint((ixbox[3]+ixbox[4])/2.0 -rect[2] -iof);
      y=inint((1/3.0)*iybox[3]+(2/3.0)*iybox[4]+ iof + 1.5*rect[3]);  

      if(ppsubwin->axes.auto_ticks[1] == FALSE)
      {
        /* we display the y tics specified by the user*/
        nbtics = ppsubwin->axes.u_nygrads;
        nbsubtics = ppsubwin->axes.nbsubtics[1];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          char *foo = ppsubwin->axes.u_ylabels[i]; 
          double ytmp = ppsubwin->axes.u_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... */
          }

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          if(ppsubwin->axes.reverse[1] == TRUE)
            ytmp = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz);
          /*              trans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz); */


          vx[0]=xm;vy[0]=ym; 

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          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);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;

          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-rect[2]/2);  */
            posi[0] = inint( xm+2*barlengthx-rect[2]); 
            posi[1]=inint( ym + 2*barlengthy + rect[3]);}


          if(ppsubwin->axes.axes_visible[1] == TRUE){
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[1] > -1 && ppsubwin->axes.axes_visible[1] )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[1];

            if((ppsubwin->logflags[1] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<=yminval || vyy1>=ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                /*   if ((xm != ixbox[3]) && (xm != ixbox[4])) */
                /*                              { */ 
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(ytmp>yminval && ytmp<ymaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[1] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.u_ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;

            } /* end NEW */
            else
            {

              double ytmp2 = ppsubwin->axes.u_ygrads[i];
              double dy = (ppsubwin->axes.u_ygrads[i+1] - ppsubwin->axes.u_ygrads[i]) / nbsubtics;
              for(j=0;j<nbsubtics;j++)
              {
                vyy1=ytmp2+dy*j;

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);
                /*                trans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz); */


                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }
          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

        }
      }
      else /* we display the computed tics */
      {
        AdaptGraduationsOnYBottomLeft(iof,x,y,size,Ticsdir,fontid,psubwin,yminval,ymaxval,fx,0.,fz);

        lastyindex = ppsubwin->axes.nygrads - 1;

        if(lastyindex == 0)
          ChooseFormatForOneGrad(c_format,&(ppsubwin->axes.ygrads[0]));
        else
          ChoixFormatE(c_format,
          ppsubwin->axes.ygrads[0],
          ppsubwin->axes.ygrads[lastyindex],
          ((ppsubwin->axes.ygrads[lastyindex])-(ppsubwin->axes.ygrads[0]))/(lastyindex));

        nbtics = ppsubwin->axes.nygrads;
        nbsubtics = ppsubwin->axes.nbsubtics[1];

        maxTicksLabelSize[0] = 0 ;
        maxTicksLabelSize[1] = 0 ;

        for(i=0;i<nbtics;i++)
        {
          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);

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          if(ppsubwin->axes.reverse[1] == TRUE)
            ytmp = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],ytmp);

          ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz);
          /*              trans3d(psubwin,1,&xm,&ym,&fx,&ytmp,&fz); */


          vx[0]=xm;vy[0]=ym; 

          barlengthx= (integer) (( Ticsdir[0])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);
          barlengthy= (integer) (( Ticsdir[1])/sqrt((double) Ticsdir[0]*Ticsdir[0]+Ticsdir[1]*Ticsdir[1])*size);

          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);
          maxTicksLabelSize[0] = Max( maxTicksLabelSize[0], rect[2] ) ;
          maxTicksLabelSize[1] = Max( maxTicksLabelSize[1], rect[3] ) ;

          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-rect[2]/2);  */
            posi[0] = inint( xm+2*barlengthx-rect[2]); 
            posi[1]=inint( ym + 2*barlengthy + rect[3]);}

          if(ppsubwin->axes.axes_visible[1] == TRUE){
            C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            if ( ppsubwin->logflags[1] == 'l' )
            {
              int smallersize = fontid[1]-2;
              int old_rect10[4];
              /*                    char str[2] = "xv"; */
              int posi10[2];

              posi10[0] = posi[0] - logrect[2];
              posi10[1] = posi[1] + logrect[3];

              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring","10",(&posi10[0]),(&posi10[1]),PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);

              C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),old_rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

              posi[0] = old_rect10[0] + old_rect10[2];
              posi[1] = (int) (old_rect10[1] - old_rect10[3]*.1);

              C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

              /* put back the current fontid */
              C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            else
              C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&ang, PD0,PD0,PD0,0L,0L);

            C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /* grid to put here */
          if ( ppsubwin->grid[1] > -1 && ppsubwin->axes.axes_visible[1] )
          {
            gstyle = pSUBWIN_FEATURE (psubwin)->grid[1];

            if((ppsubwin->logflags[1] =='l') && (i != nbtics-1))
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<=yminval || vyy1>=ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                /*    if ((xm != ixbox[3]) && (xm != ixbox[4])) */
                /*                              {  */
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
                /*      } */
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;
            }
            else
            {
              if(ytmp>yminval && ytmp<ymaxval) 
              {
                xg[0]= xm;  yg[0]= ym;  
                if (Ishidden(psubwin))
                { xg[1]= xm; yg[1]= iybox[0] -iybox[5]+ym; }
                else
                {xg[1]= ixbox[1] - ixbox[3] +xm; yg[1]= iybox[5] - iybox[4] +ym; } 
                C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F (dr) ("xset", "line style",&gridStyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                xg[0]= xg[1]; yg[0]= yg[1];
                xg[1] = ixbox[1] - ixbox[3] +xm; yg[1]=  iybox[0] - iybox[4] +ym;
                C2F(dr)("xsegs","v", xg, yg, &ns,&gstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
                C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
              }
            }
          }

          /* and subtics */
          if(i != nbtics-1)
          {
            if(ppsubwin->logflags[1] =='l')
            {
              double tmp[2];
              double pas=0;
              double * tmp_log_grads = (double *) NULL;


              double * grads = ppsubwin->axes.ygrads;

              tmp[0] = exp10(grads[i]);
              tmp[1] = exp10(grads[i+1]);
              pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );

              if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
                sciprint("Error allocating tmp_log_grads\n");
                return -1;
              }

              for(j=0;j<nbsubtics;j++) tmp_log_grads[j] = log10(tmp[0]+(j)*pas);

              for(j=0;j<nbsubtics;j++)
              {
                vyy1 = tmp_log_grads[j];

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
              FREE(tmp_log_grads); tmp_log_grads = (double *) NULL;

            } /* end NEW */
            else
            {

              double ytmp2 = ppsubwin->axes.ygrads[i];
              double dy = (ppsubwin->axes.ygrads[i+1] - ppsubwin->axes.ygrads[i]) / nbsubtics;
              for(j=0;j<nbsubtics;j++)
              {
                vyy1=ytmp2+dy*j;

                if(vyy1<yminval || vyy1>ymaxval) continue;

                if(ppsubwin->axes.reverse[1] == TRUE)
                  vyy1 = InvAxis(ppsubwin->FRect[1],ppsubwin->FRect[3],vyy1);

                ComputeGoodTrans3d(psubwin,1,&xm,&ym,&fx,&vyy1,&fz);

                if (IsDownAxes(psubwin))
                {
                  vx[1]=vx[0]=xm;
                  vy[0]=ym;
                  vy[1]=vy[0]+iof/4;
                }
                else
                {
                  vx[0]=xm;vy[0]=ym;
                  vx[1]= (integer) (vx[0]+barlengthx/2.0);
                  vy[1]= (integer) (vy[0]+barlengthy/2.0);
                }

                if(ppsubwin->axes.axes_visible[1] == TRUE)
                  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          }

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/
        }
      }
    }

    if ( sciGetVisibility(ppsubwin->mon_y_label) )
    {  
      sciLabel * ppLabel =  pLABEL_FEATURE(ppsubwin->mon_y_label) ;
      if( ppLabel->auto_rotation )
      {
        sciSetFontOrientation(ppsubwin->mon_y_label, 0 ) ;
      }

      if( ppLabel->auto_position )
      {

        int segmentStart[2] = { ixbox[3], iybox[3] } ;
        int segmentEnd[2]   = { ixbox[4], iybox[4] } ;

        /* add the bar size and ticks label size to the offset */
        int offset[2] = { constOffset[0] + maxTicksLabelSize[0] + abs( barlengthx ), 
          constOffset[1] + maxTicksLabelSize[1] + abs( barlengthy )  } ;
        computeLabelAutoPos( ppsubwin->mon_y_label, segmentStart, segmentEnd, offset ) ;
      }
      /* a trick to force the display with 2d scale */
      drawTextEntity( ppLabel->text ) ;

    }
  }
  /* reset font to its current size & to current color*/ 
  if ( fontsize != -1 ){
    fontid[1] = fontsize_kp;
    C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }
  if ( textcolor != -1 || ticscolor != -1 ) 
    C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  /***/
  /* FREE(loc); */


  return 0;
}

Here is the call graph for this function:

static void axesplot	(	char *	,
		sciPointObj *
	)			[static]

Definition at line 830 of file Axes.c.

References sciSubWindow::axes, AXES::axes_visible, BT_HIDDEN_AXIS, BT_OFF, C2F, Cscale, dir, dr(), FALSE, sciSubWindow::isoview, L, AXES::nxgrads, AXES::nygrads, PD0, PI0, pSUBWIN_FEATURE, AXES::reverse, SciAxisNew(), SciDrawLines(), sciGetBoxType(), sciGetFontDeciWidth(), sciGetFontForeground(), sciGetFontStyle(), sciGetForeground(), sciSubWindow::tight_limits, TRUE, wcscalelist::WIRect1, AXES::xdir, AXES::xgrads, AXES::xlim, AXES::ydir, AXES::ygrads, and AXES::ylim.

Referenced by axis_draw(), and axis_draw2().

{
  char dir = 'l';
  char c = (strlen(strflag) >= 3) ? strflag[2] : '1';
  int seg=0;
  int fontsize = -1 ,textcolor = -1 ,ticscolor = -1 ; /* default values */
  int fontstyle= 0;
  double  x1,y1_;
  char xstr,ystr; 
  char dirx = 'd';


  int lastxindex = 0, lastyindex = 0;
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);

  if( ppsubwin->tight_limits == TRUE || ppsubwin->isoview == TRUE)
    {
      switch ( c )
        {
        case '3' : /* right axis */
          x1= ppsubwin->axes.xlim[1];
          y1_= ppsubwin->axes.ylim[0];
          dir = 'r';
          break;
        case '4' : /* centred axis */
          seg=1;
          x1= (ppsubwin->axes.xlim[0]+ppsubwin->axes.xlim[1])/2.0;
          y1_= (ppsubwin->axes.ylim[0]+ppsubwin->axes.ylim[1])/2.0;
          break ;
        case '5': /* centred at (0,0) */
          seg=1;
          x1 = y1_ = 0.0;
          break;
        case '1' : /* left axis */
        default :
          x1=  ppsubwin->axes.xlim[0];
          y1_=  ppsubwin->axes.ylim[1];
          break;
        }
    }
  else  /* tight_limits == FALSE */
    {
      lastxindex = ppsubwin->axes.nxgrads - 1;
      lastyindex = ppsubwin->axes.nygrads - 1;
     
        switch ( c )
        {
        case '3' : /* right axis */
          x1= ppsubwin->axes.xgrads[lastxindex];
          y1_= ppsubwin->axes.ygrads[0];
          dir = 'r';
          break;
        case '4' : /* centred axis */
          seg=1;
          x1= (ppsubwin->axes.xgrads[0]+ppsubwin->axes.xgrads[lastxindex])/2.0;
          y1_= (ppsubwin->axes.ygrads[0]+ppsubwin->axes.ygrads[lastyindex])/2.0;
          break ;
        case '5': /* centred at (0,0) */
          seg=1;
          x1 = y1_ = 0.0;
          break;
        case '1' : /* left axis */
        default :
          x1= ppsubwin->axes.xgrads[0];
          y1_= ppsubwin->axes.ygrads[0];
        break;
        }
    }
       


  if(ppsubwin->tight_limits == TRUE || ppsubwin->isoview == TRUE)
    {
      if (c != '4')
        {
          xstr=ppsubwin->axes.xdir;
          if(ppsubwin->axes.reverse[1] == FALSE)
            { /* y reverse axis : NO */
              switch (xstr)
                {
                case 'u':
                  y1_= ppsubwin->axes.ylim[1];
                  dirx='u';
                  break;
                case 'c':
                  y1_= (ppsubwin->axes.ylim[0]>0.0)?ppsubwin->axes.ylim[0]:0.0;
                  y1_= (ppsubwin->axes.ylim[1]<0.0)?ppsubwin->axes.ylim[0]:y1_;
                  seg =1;
                  dirx ='d';
                  break;
                default :
                  y1_= ppsubwin->axes.ylim[0];
                  dirx ='d';
                  break;
                }
            }
          else
            { /* y reverse axis : YES */
              switch (xstr)
                {
                case 'u':
                  y1_= ppsubwin->axes.ylim[0];
                  dirx='u';
                  break;
                case 'c':
                  y1_= (ppsubwin->axes.ylim[0]>0.0)?ppsubwin->axes.ylim[0]:0.0;
                  y1_= (ppsubwin->axes.ylim[1]<0.0)?ppsubwin->axes.ylim[0]:y1_;
                  seg =1;
                  dirx ='d';
                  break;
                default :
                  y1_= ppsubwin->axes.ylim[1];
                  dirx ='d';
                  break;
                }
            }

          ystr=ppsubwin->axes.ydir;
          if(ppsubwin->axes.reverse[0] == FALSE)
            { /* x reverse axis : NO */
              switch (ystr)
                {
                case 'r':
                  x1= ppsubwin->axes.xlim[1];
                  dir='r';
                  break;
                case 'c':
                  x1=(ppsubwin->axes.xlim[0]>0.0)?ppsubwin->axes.xlim[0]:0.0;
                  x1=(ppsubwin->axes.xlim[1]<0.0)?ppsubwin->axes.xlim[0]:x1;
                  seg =1;
                  dir ='l';
                  break;
                default :
                  x1= ppsubwin->axes.xlim[0];
                  dir ='l';
                  break;
                }
            }
          else
            { /* x reverse axis : YES */
              switch (ystr)
                {
                case 'r':
                  x1= ppsubwin->axes.xlim[0];
                  dir='r';
                  break;
                case 'c':
                  x1=(ppsubwin->axes.xlim[0]>0.0)?ppsubwin->axes.xlim[0]:0.0;
                  x1=(ppsubwin->axes.xlim[1]<0.0)?ppsubwin->axes.xlim[0]:x1;
                  seg =1;
                  dir ='l';
                  break;
                default :
                  x1= ppsubwin->axes.xlim[1];
                  dir ='l';
                  break;
                }
            }
        }
    }
  else  /* tight_limits == FALSE */
    {
      lastxindex = ppsubwin->axes.nxgrads - 1;
      lastyindex = ppsubwin->axes.nygrads - 1;
      
      if (c != '4')
        {
          xstr=ppsubwin->axes.xdir;
          if(ppsubwin->axes.reverse[1] == FALSE)
            { /* y reverse axis : NO */
              switch (xstr)
                {
                case 'u':
                  y1_=ppsubwin->axes.ygrads[lastyindex];
                  dirx='u';
                  break;
                case 'c':
                  y1_=(ppsubwin->axes.ygrads[0]>0.0)?ppsubwin->axes.ygrads[0]:0.0;
                  y1_=(ppsubwin->axes.ygrads[lastyindex]<0.0)?ppsubwin->axes.ygrads[0]:y1_;
                  seg =1;
                  dirx ='d';
              break;
                default :
                  y1_= ppsubwin->axes.ygrads[0];
                  dirx ='d';
                  break;
                }
            }
          else
            { /* y reverse axis : YES */
              switch (xstr)
                {
                case 'u':
                  y1_=ppsubwin->axes.ygrads[0];
                  dirx='u';
                  break;
                case 'c':
                  y1_=(ppsubwin->axes.ygrads[0]>0.0)?ppsubwin->axes.ygrads[0]:0.0;
                  y1_=(ppsubwin->axes.ygrads[lastyindex]<0.0)?ppsubwin->axes.ygrads[0]:y1_;
                  seg =1;
                  dirx ='d';
                  break;
                default :
                  y1_= ppsubwin->axes.ygrads[lastyindex];
                  dirx ='d';
                  break;
                }
            }
          
          ystr=ppsubwin->axes.ydir;
          if(ppsubwin->axes.reverse[0] == FALSE)
            { /* x reverse axis : NO */
              switch (ystr)
                {
                case 'r':
                  x1= ppsubwin->axes.xgrads[lastxindex];
                  dir='r';
                  break;
                case 'c':
                  x1=(ppsubwin->axes.xgrads[0]>0.0)?ppsubwin->axes.xgrads[0]:0.0;
                  x1=(ppsubwin->axes.xgrads[lastxindex]<0.0)?ppsubwin->axes.xgrads[0]:x1;
                  seg =1;
                  dir ='l';
                  break;
                default :
                  x1= ppsubwin->axes.xgrads[0];
                  dir ='l';
                  break;
                }
            }
          else
            { /* x reverse axis : YES */
              switch (ystr)
                {
                case 'r':
                  x1= ppsubwin->axes.xgrads[0];
                  dir='r';
                  break;
                case 'c':
                  x1=(ppsubwin->axes.xgrads[0]>0.0)?ppsubwin->axes.xgrads[0]:0.0;
                  x1=(ppsubwin->axes.xgrads[lastxindex]<0.0)?ppsubwin->axes.xgrads[0]:x1;
                  seg =1;
                  dir ='l';
                  break;
                default :
                  x1= ppsubwin->axes.xgrads[lastxindex];
                  dir ='l';
                  break;
                }
            }
        }
    }
  
  ticscolor=sciGetForeground(psubwin);
  textcolor=sciGetFontForeground(psubwin);
  fontsize=sciGetFontDeciWidth(psubwin)/100;
  fontstyle=sciGetFontStyle(psubwin);
 
  SciAxisNew(dirx,psubwin,y1_,fontsize,fontstyle,textcolor,ticscolor,seg);
  
  SciAxisNew(dir,psubwin,x1,fontsize,fontstyle,textcolor,ticscolor,seg);

  /* Once the 2 axes are plotted, we can draw :
     1. the axes lines
     2. the box lines over if necessary (i.e. seg == 1) */
  if ( ppsubwin->axes.axes_visible[0] )
  {
    SciDrawLines(dirx,psubwin,y1_,textcolor,ticscolor);
  }
  SciDrawLines(dir, psubwin,x1,textcolor,ticscolor);
  
  
  if ( c != '4' && c != '5' )
  {
    if ( sciGetBoxType(psubwin) == BT_OFF || sciGetBoxType(psubwin) == BT_HIDDEN_AXIS )
    {
      seg = 1 ;
    }
    else
    {
      C2F(dr)("xrect","v",&Cscale.WIRect1[0],&Cscale.WIRect1[1],&Cscale.WIRect1[2],&Cscale.WIRect1[3], 
              PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void axis_3ddraw	(	sciPointObj *	pobj,
		double *	xbox,
		double *	ybox,
		double *	zbox,
		integer *	InsideU,
		integer *	InsideD
	)

axis_3ddraw 10/2003

Author:

Djalel Abdemouche Should be in Axes.c file

l'enveloppe cvxe

Definition at line 2825 of file Axes.c.

References Abs, sciSubWindow::alpha, Alpha, sciSubWindow::axes, Axes3dStrings2(), BT_BACK_HALF, BT_OFF, BT_ON, C2F, ComputeCorrectXindAndInsideUD(), dbox(), dr(), DrawAxis(), AXES::flag, AXES::hiddenAxisColor, sciSubWindow::hiddenstate, i, Ishidden(), L, n, p, PD0, PI0, pSUBWIN_FEATURE, SCI_SUBWIN, sciAxesVerticesIndices(), sciGetBackground(), sciGetBoxType(), sciGetEntityType(), sciGetForeground(), sciGetLineStyle(), sciGetLineWidth(), sciSetGoodIndex(), sciSubWindow::theta, updateScale3d(), x, XScale(), and YScale().

Referenced by drawSubWinEntity(), and UpdateSubwinScale().

{
  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);
      }
    }
    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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void axis_draw

(

char

strflag[]

)

Definition at line 62 of file Axes.c.

References axesplot(), BT_ON, C2F, Cscale, dr(), i, L, n, p, PD0, PI0, pSUBWIN_FEATURE, sciGetBackground(), sciGetCurrentSubWin(), and wcscalelist::WIRect1.

{ 
        static sciPointObj * psubwin;
  /* using foreground to draw axis */
  integer verbose=0,narg,xz[10],fg,i,ixbox[5],iybox[5],p=5,n=1,color,color_kp; 
 /*  int isoflag = -1; */
  char c = (strlen(strflag) >= 3) ? strflag[2] : '1';
  C2F(dr)("xget","foreground",&verbose,&fg,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","line style",&verbose,xz,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","line style",(i=1,&i),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","color",&verbose,xz+1,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","color",&fg,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 


  psubwin = sciGetCurrentSubWin();
  
  /* F.Leray test on color here*/
  color=sciGetBackground(psubwin);
  

  ixbox[0]=ixbox[4]=Cscale.WIRect1[0];iybox[0]=iybox[4]=Cscale.WIRect1[1];
  ixbox[1]=ixbox[0];iybox[1]=Cscale.WIRect1[1]+Cscale.WIRect1[3];
  ixbox[2]=Cscale.WIRect1[0]+Cscale.WIRect1[2];iybox[2]=iybox[1];
  ixbox[3]=ixbox[2];iybox[3]=iybox[0];
  C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","pattern",&color,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_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

  switch ( c) 
    {
    case '0' :
      break ;
    case '2' :
      pSUBWIN_FEATURE (psubwin)->axes.rect = BT_ON;  /* NG */
      C2F(dr)("xrect","xv",&Cscale.WIRect1[0],&Cscale.WIRect1[1],&Cscale.WIRect1[2],&Cscale.WIRect1[3]
              ,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      break;
    default :
      axesplot(strflag,psubwin);
      break;
    }



  C2F(dr)("xset","line style",xz,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","color",xz+1,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);


}

Here is the call graph for this function:

void axis_draw2

(

char

strflag[]

)

Definition at line 116 of file Axes.c.

References axesplot(), BT_ON, C2F, Cscale, dr(), i, L, PD0, PI0, pSUBWIN_FEATURE, sciGetBackground(), sciGetCurrentSubWin(), and wcscalelist::WIRect1.

Referenced by DrawAxes(), and drawSubWinEntity().

{ 
        static sciPointObj * psubwin;
  /* using foreground to draw axis */
  integer verbose=0,narg,xz[10],fg,i,color; 
  /*  int isoflag = -1; */
  char c = (strlen(strflag) >= 3) ? strflag[2] : '1';
  C2F(dr)("xget","foreground",&verbose,&fg,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","line style",&verbose,xz,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","line style",(i=1,&i),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","color",&verbose,xz+1,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","color",&fg,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
  
  psubwin = sciGetCurrentSubWin();
  
  /* F.Leray test on color here*/
  color=sciGetBackground(psubwin);
  
  switch ( c) 
    {
      /*case '0' :
        break ;*/
    case '2' :
      pSUBWIN_FEATURE (psubwin)->axes.rect = BT_ON;
      
      C2F(dr)("xrect","xv",&Cscale.WIRect1[0],&Cscale.WIRect1[1],&Cscale.WIRect1[2],&Cscale.WIRect1[3]
              ,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      break;
    default :
      axesplot(strflag,psubwin);
      break;
    }

  C2F(dr)("xset","line style",xz,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","color",xz+1,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
}

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL CheckDisplay	(	double	fact_h,
		double	fact_w,
		char	logflag,
		char *	foo,
		int *	posi,
		int *	fontid,
		int *	old_rect
	)

Definition at line 2266 of file Axes.c.

References C2F, dr(), FALSE, getTicksLabelBox(), i, IsInsideRectangle(), L, PD0, PI0, and TRUE.

{
  int rect[4],i;
  int point[4][2];
  int logrect[4] ;
  int XX = 0 ;
  int YY = 0 ;
  
  if(old_rect[0] == 0 && old_rect[1] == 0 && old_rect[2] == 0 && old_rect[3] == 0)
  {
    return TRUE ;
  }
  
  C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
  
  /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
  C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);   
 
  getTicksLabelBox( 1.0, 1.0, foo, posi, fontid, logflag, rect, TRUE ) ;
 
  point[0][0] = rect[0]; /* upper left point */
  point[0][1] = rect[1];
  
  point[1][0] = rect[0]; /* lower left point */
  point[1][1] = rect[1]+rect[3];
  
  point[2][0] = rect[0]+rect[2]; /* lower right point */
  point[2][1] = rect[1]+rect[3];
  
  point[3][0] = rect[0]+rect[2]; /* upper right point */
  point[3][1] = rect[1];
  
  for(i=0;i<4;i++)
  {
    if( !IsInsideRectangle(old_rect,point[i]) )
    {
      return FALSE; /* If one inside the old_rect, DO NOT display the graduation ! */
    }
  }

  return TRUE;
}

Here is the call graph for this function:

BOOL checkRedrawing

(

void

)

Definition at line 2243 of file Axes.c.

References FALSE, reinitSubWin(), sciGetAddPlot(), sciGetCurrentSubWin(), and TRUE.

Referenced by champg(), fec(), Objarc(), Objdrawaxis(), Objfpoly(), Objplot3d(), Objpoly(), Objrect(), Objsegs(), Objstring(), Objtitle(), plot2dn(), xgray(), xgray1(), and xgray2().

{
  
  sciPointObj * pSubWin = sciGetCurrentSubWin() ;
  if ( !sciGetAddPlot( pSubWin ) )
  {
      /* redraw the axis */
      reinitSubWin( pSubWin ) ;
      return TRUE ;
  }
  return FALSE ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL checkXAxes2dTics	(	sciPointObj *	psubwin,
		char	side,
		double	y,
		char *	cFormat,
		int	fontId[2],
		int	smallersize
	)

Definition at line 2399 of file Axes.c.

References sciSubWindow::axes, C2F, CheckDisplay(), Cscale, dr(), FALSE, FindXYMinMaxAccordingTL(), sciSubWindow::firsttime_x, foo(), getTicksLabelBox(), i, inint, L, sciSubWindow::logflags, Max, AXES::nxgrads, PD0, PI0, pSUBWIN_FEATURE, TRUE, wcscalelist::WIRect1, XGradPosition(), AXES::xgrads, XScale(), and YScale().

Referenced by updateXaxesTics().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin) ;
  double xminval, yminval, xmaxval, ymaxval ;
  int  /* flag=0, */xx=0,yy=0,rect[4] ;
  int xm[2],ym[2];
  int barlength = 0;
  int posi[2];
  int prevFontId[2] ;
  int verbose = 0 ;
  int narg ;
  
  double factX = 1.2 ;
  double factY = 1.2 ;
  int nbtics = 0,i ;
  int prevRect[4] = { 0, 0, 0, 0 } ;
  
  /*--------*/
  /* x axis */
  /*--------*/
  
  ym[0] = YScale(y) ;

  barlength =  Max( (integer) (Cscale.WIRect1[3]/50.0), 2 ) ;

  ppsubwin->firsttime_x = TRUE ;

  /* suppose auto_ticks is off */
  /* here i only need x data (ymin ymax are computed but not used after) */
  FindXYMinMaxAccordingTL( psubwin, &xminval, &yminval, &xmaxval, &ymaxval ) ;
  nbtics = ppsubwin->axes.nxgrads ;
  
  C2F(dr)("xget","font",&verbose,prevFontId,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
  C2F(dr)("xset","font",fontId,fontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
  
  for( i = 0 ; i < nbtics; i++ )
  {
    
    char foo[256];
    double xtmp = ppsubwin->axes.xgrads[i] ;

    if( xtmp < xminval || xtmp > xmaxval ) 
    {
      continue; /* cas ou TL est ON et on a des graduations qui ne seront pas affichées de tte facon */
                /* donc autant ne pas aller plus loin dans l'algo... */
    }
    
    sprintf(foo, cFormat,xtmp);
    
    /* compute the bounding box of the label */
   
    C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    
    xm[0] = XScale(xtmp);
    posi[0] = inint( xm[0] - rect[2]/2.0 ) ;
    
    if ( side == 'd')
    {
      /* ticks are drawn under the axis */
      posi[1] = inint( ym[0] + 1.2 * barlength + rect[3] ) ;
    }
    else /* side = 'u' */
    {
      /* ticks are drawn above the axis */
      posi[1] = inint( ym[0] - 1.2 * barlength ) ;
    }

    /* check that the new display doesnot concealed the previous */
    if ( !CheckDisplay( factX, factY,
                        ppsubwin->logflags[0],
                        foo, posi,
                        fontId, prevRect ) )
    {
      /* put the font back */
      C2F(dr)("xset","font",prevFontId,prevFontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
      return FALSE ;
    }
    
    /* get the boundig rectangle of the new label */
    getTicksLabelBox( factX, factY, foo, posi, fontId, ppsubwin->logflags[0],  prevRect, FALSE ) ;

    XGradPosition(psubwin,posi[1],rect[3]) ;
    
  }


  /* put the font back */
  C2F(dr)("xset","font",prevFontId,prevFontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;

  return TRUE ;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL checkYAxes2dTics	(	sciPointObj *	psubwin,
		char	side,
		double	x,
		char *	cFormat,
		int	fontId[2],
		int	smallersize
	)

Definition at line 2499 of file Axes.c.

References sciSubWindow::axes, C2F, CheckDisplay(), Cscale, dr(), FALSE, FindXYMinMaxAccordingTL(), sciSubWindow::firsttime_y, foo(), getTicksLabelBox(), i, inint, L, sciSubWindow::logflags, Max, AXES::nygrads, PD0, PI0, pSUBWIN_FEATURE, TRUE, wcscalelist::WIRect1, XScale(), YGradPosition(), AXES::ygrads, and YScale().

Referenced by updateYaxesTics().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin) ;
  double xminval, yminval, xmaxval, ymaxval ;
  int  /* flag=0, */xx=0,yy=0,rect[4] ;
  int xm[2],ym[2];
  int barlength = 0;
  int posi[2];
  int prevFontId[2] ;
  int verbose = 0 ;
  int narg ;
  double factX = 1.5 ;
  double factY = 1.5 ;
  int nbtics = 0,i ;
  int prevRect[4] = { 0, 0, 0, 0 } ;
  
  /*--------*/
  /* y axis */
  /*--------*/
  
  xm[0] = XScale(x) ;

  barlength =  Max( (integer) (Cscale.WIRect1[2]/75.0), 2 ) ;

  ppsubwin->firsttime_y = TRUE ;

  /* suppose auto_ticks is off */
  /* here i only need x data (ymin ymax are computed but not used after) */
  FindXYMinMaxAccordingTL( psubwin, &xminval, &yminval, &xmaxval, &ymaxval ) ;
  nbtics = ppsubwin->axes.nygrads ;
  
  C2F(dr)("xget","font",&verbose,prevFontId,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
  C2F(dr)("xset","font",fontId,fontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); /* fix bug noticed by R.N. */
  
  for( i = 0 ; i < nbtics; i++ )
  {
    
    char foo[256];
    double ytmp = ppsubwin->axes.ygrads[i] ;

    if( ytmp < yminval || ytmp > ymaxval ) 
    {
      continue; /* cas ou TL est ON et on a des graduations qui ne seront pas affichées de tte facon */
                /* donc autant ne pas aller plus loin dans l'algo... */
    }
    
    sprintf(foo, cFormat,ytmp);
    
    /* compute the bounding box of the label */
   
    C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    
    ym[0] = YScale(ytmp);
    posi[1] = inint( ym[0] + rect[2]/2.0 ) ;
    
    if ( side == 'r')
    {
      /* ticks are drawn under the axis */
      posi[0] = inint( xm[0] + 1.2 * barlength ) ;
    }
    else /* side = 'l' */
    {
      /* ticks are drawn above the axis */
      posi[0] = inint( xm[0] - 1.2 * barlength - rect[2] ) ;
    }

    /* check that the new display doesnot concealed the previous */
    if ( !CheckDisplay( factX, factY,
                        ppsubwin->logflags[1],
                        foo, posi,
                        fontId, prevRect ) )
    {
      /* put the font back */
      C2F(dr)("xset","font",prevFontId,prevFontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
      return FALSE ;
    }
    
    /* get the boundig rectangle of the new label */
    getTicksLabelBox( factX, factY, foo, posi, fontId, ppsubwin->logflags[1],  prevRect, FALSE ) ;

    YGradPosition(psubwin,posi[0],rect[2]) ;
    
  }


  /* put the font back */
  C2F(dr)("xset","font",prevFontId,prevFontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
  
  return TRUE ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void clearSubWin

(

sciPointObj *

pSubWin

)

Definition at line 2155 of file Axes.c.

References DestroyAllGraphicsSons(), sciPointObj::entitytype, NULL, tagSons::pnext, tagSons::pointobj, SCI_LABEL, and sciGetSons().

Referenced by reinitSubWin().

{
  sciSons * curSon = sciGetSons (pSubWin);
  
  while ( curSon != NULL && curSon->pointobj != NULL )
  {
    if ( curSon->pointobj->entitytype != SCI_LABEL )
    {
      DestroyAllGraphicsSons (curSon->pointobj) ;
      curSon = sciGetSons ( pSubWin ) ;
    }
    else
    {
      curSon = curSon->pnext ;
    }
    
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DrawAxesBackground

(

void

)

Definition at line 155 of file Axes.c.

References C2F, Cscale, dr(), i, L, n, p, PD0, PI0, sciGetBackground(), sciGetCurrentSubWin(), and wcscalelist::WIRect1.

Referenced by drawSubWinEntity().

{ 
        static sciPointObj * psubwin;
  /* using foreground to draw axis */
  integer verbose=0,narg,xz[10],fg,i,ixbox[5],iybox[5],p=5,n=1,color,color_kp; 
 /*  int isoflag = -1; */
  C2F(dr)("xget","foreground",&verbose,&fg,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","line style",&verbose,xz,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","line style",(i=1,&i),PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xget","color",&verbose,xz+1,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","color",&fg,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 

  psubwin = sciGetCurrentSubWin();
    
  /* F.Leray test on color here*/
  color=sciGetBackground(psubwin);
  
  ixbox[0]=ixbox[4]=Cscale.WIRect1[0];iybox[0]=iybox[4]=Cscale.WIRect1[1];
  ixbox[1]=ixbox[0];iybox[1]=Cscale.WIRect1[1]+Cscale.WIRect1[3];
  ixbox[2]=Cscale.WIRect1[0]+Cscale.WIRect1[2];iybox[2]=iybox[1];
  ixbox[3]=ixbox[2];iybox[3]=iybox[0]; 
  C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","pattern",&color,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_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);          

  C2F(dr)("xset","line style",xz,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","color",xz+1,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);


}

Here is the call graph for this function:

Here is the caller graph for this function:

void drawAxesGrid

(

sciPointObj *

psubwin

)

Draw the grid of an axes object if needed.

Definition at line 2808 of file Axes.c.

References DrawXGrid(), DrawYGrid(), and pSUBWIN_FEATURE.

Referenced by drawSubWinEntity().

{
  if( pSUBWIN_FEATURE(psubwin)->grid[0] > -1 )
  {
    DrawXGrid(psubwin);
  }

  if( pSUBWIN_FEATURE(psubwin)->grid[1] > -1 )
  {
    DrawYGrid(psubwin);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DrawAxis	(	double	xbox[8],
		double	ybox[8],
		integer	Indices[4],
		integer	style
	)

Trace un triedre : Indices[4] donne les indices des points qui constituent le triedre dans les tableaux xbox et ybox

DJ.Abdemouche 2003

Definition at line 3177 of file Axes.c.

References C2F, dr(), i, iflag, j, L, PD0, PI0, pSUBWIN_FEATURE, sciGetCurrentSubWin(), sciGetLineStyle(), XScale(), and YScale().

{
  integer ixbox[6],iybox[6],npoly=6,lstyle[6],verbose=0,narg_,hiddencolor;
  integer i, iflag=0, j=1;
  sciPointObj *psubwin;
  for ( i = 0 ; i <= 4 ; i=i+2)
  {
    ixbox[i]=XScale(xbox[Indices[0]]);iybox[i]=YScale(ybox[Indices[0]]);
  }
  ixbox[1]=XScale(xbox[Indices[1]]);iybox[1]=YScale(ybox[Indices[1]]);
  ixbox[3]=XScale(xbox[Indices[2]]);iybox[3]=YScale(ybox[Indices[2]]);
  ixbox[5]=XScale(xbox[Indices[3]]);iybox[5]=YScale(ybox[Indices[3]]);
  C2F(dr)("xget","line style",&verbose,lstyle,&narg_,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
  psubwin = sciGetCurrentSubWin(); 
  hiddencolor = pSUBWIN_FEATURE (psubwin)->hiddencolor;
  j = sciGetLineStyle (psubwin) ;

  C2F(dr)("xset","line style",&j,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xsegs","v",ixbox,iybox,&npoly,&style,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xset","line style",lstyle,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

}

Here is the call graph for this function:

static int DrawXGrid

(

sciPointObj *

psubwin

)

[static]

Definition at line 1278 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, AXES::axes_visible, C2F, dr(), FALSE, FindXYMinMaxAccordingTL(), FREE, sciSubWindow::grid, i, iflag, j, L, sciSubWindow::logflags, MALLOC, AXES::nbsubtics, NULL, AXES::nxgrads, pas, PD0, PI0, pSUBWIN_FEATURE, sciprint(), style, AXES::u_nxgrads, AXES::u_xgrads, val, AXES::xgrads, XScale(), and YScale().

Referenced by drawAxesGrid().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval,yminval,xmaxval,ymaxval;
  int verbose=0,narg;

  int vx[2],vy[2],ym[2];
  int dash[6],lineMode=2;
  int ns=2,style=0,iflag=0;
  
  double * grads = (double *) NULL;
  int nbtics = 0,i,j;
  int nbsubtics = ppsubwin->axes.nbsubtics[0];
  char logflag = ppsubwin->logflags[0];
   
  FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval);
  
  
  ym[0] = YScale(yminval);
  ym[1] = YScale(ymaxval);

  if(ppsubwin->axes.auto_ticks[0] == FALSE){
    grads =  ppsubwin->axes.u_xgrads;
    nbtics = ppsubwin->axes.u_nxgrads;
  }
  else{
    grads =  ppsubwin->axes.xgrads;
    nbtics = ppsubwin->axes.nxgrads;
  }
  
  /* Grid style */
  C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F (dr) ("xset", "line style",&lineMode,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  style = ppsubwin->grid[0];
  
  /* Grid based on tics */
  for(i=0;i<nbtics;i++)
    {
      double xtmp = grads[i];
      vx[0] = vx[1] = XScale(xtmp);
      
      if(xtmp<xminval || xtmp>xmaxval) continue;           
      
      vy[0]= ym[0];vy[1]=  ym[1];
      if ( ppsubwin->axes.axes_visible[0] )
      {
        C2F(dr)("xsegs","v", vx, vy, &ns,&style,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
    }
  
  /* Grid based on subtics : ONLY for log. case */
  if(logflag =='l')
    {
      double tmp[2];
      double pas=0;
      double * tmp_log_grads = (double *) NULL;
      
      for(i=0;i<nbtics-1;i++)
        {
          int k;
          tmp[0] = exp10(grads[i]);
          tmp[1] = exp10(grads[i+1]);
          pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );
          
          if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
            sciprint("Error allocating tmp_log_grads\n");
            return -1;
          }
          
          for(k=0;k<nbsubtics;k++) tmp_log_grads[k] = log10(tmp[0]+(k)*pas);
          
          for(j=0;j<nbsubtics;j++)
            {
              double val = tmp_log_grads[j];
              vx[0] = vx[1] = XScale(val);
              
              if(val<xminval || val>xmaxval) continue;    
              
              vy[0]= ym[0];vy[1]=  ym[1];
              if ( ppsubwin->axes.axes_visible[0] )
              {
                C2F(dr)("xsegs","v", vx, vy, &ns,&style,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          
          FREE(tmp_log_grads); tmp_log_grads = NULL;
        }
    }
 
  /* return to solid mode (in default mode) */
  C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int DrawXSubTics	(	char	pos,
		sciPointObj *	psubwin,
		double	xy,
		int	ticscolor,
		int	color_kp
	)			[static]

Definition at line 1156 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, AXES::axes_visible, C2F, Cscale, dr(), dx, FALSE, FindXYMinMaxAccordingTL(), FREE, i, iflag, j, L, sciSubWindow::logflags, MALLOC, Max, AXES::nbsubtics, NULL, AXES::nxgrads, pas, PD0, PI0, pSUBWIN_FEATURE, sciprint(), AXES::u_nxgrads, AXES::u_xgrads, val, wcscalelist::WIRect1, AXES::xgrads, XScale(), and YScale().

Referenced by SciAxisNew().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval,yminval,xmaxval,ymaxval;
   
  int vx[2],vy[2],ym[2];
  int barlength = 0;
  int ns=2,iflag=0;
  
  int nbtics = 0,i,j;
  int nbsubtics = ppsubwin->axes.nbsubtics[0];
  char logflag = ppsubwin->logflags[0];
  
  double *grads = (double *) NULL;

  ym[0] = YScale(xy);
   
  barlength =  (integer) (Cscale.WIRect1[3]/50.0);
  
  FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval); /* here i only need x data (ymin ymax are computed but not used after) */
 

  if(ppsubwin->axes.auto_ticks[0] == FALSE){
    grads =  ppsubwin->axes.u_xgrads;
    nbtics = ppsubwin->axes.u_nxgrads;
  }
  else{
    grads =  ppsubwin->axes.xgrads;
    nbtics = ppsubwin->axes.nxgrads;
  }
  
  
  if(logflag =='l')
    {
      double tmp[2];
      double pas=0;
      double * tmp_log_grads = (double *) NULL;
      
      for(i=0;i<nbtics-1;i++)
        {
          int k;
          tmp[0] = exp10(grads[i]);
          tmp[1] = exp10(grads[i+1]);
          pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );
          
          if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
            sciprint("Error allocating tmp_log_grads\n");
            return -1;
          }
          
          for(k=0;k<nbsubtics;k++) tmp_log_grads[k] = log10(tmp[0]+(k)*pas);
          
          for(j=0;j<nbsubtics;j++)
            {
              double val = tmp_log_grads[j];
              /* the length of the ticks in pixels */
              /* minimum 2 pixels */
              /* use of integer division for speed */
              int ticksLength =  Max( ( 3 * barlength ) / 4,  2 ) ;
              vx[0] = vx[1] = XScale(val);
              
              if(val<xminval || val>xmaxval) continue;     
              
              if ( pos == 'd' ) 
              { 
                vy[0] = ym[0] ;
                vy[1] = ym[0] + ticksLength ; 
              }
              else 
              { 
                vy[0] = ym[0] ; 
                vy[1] = ym[0] - ticksLength ;
              }
              if ( ppsubwin->axes.axes_visible[0] )
              {
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          
          FREE(tmp_log_grads); tmp_log_grads = NULL;
        }
    }
  else
    {
      for(i=0;i<nbtics-1;i++)
        {
          double xtmp = grads[i];
          double dx = (grads[i+1]-grads[i]) / nbsubtics;
          for( j = 0 ; j < nbsubtics ; j++ )
            {
              double val = xtmp+dx*j;
              /* the length of the ticks in pixels */
              /* minimum 2 pixels */
              /* use of integer division for speed */
              int ticksLength =  Max( ( 3 * barlength ) / 4,  2 ) ;
              vx[0] = vx[1] = XScale(val);
              
              if(val<xminval || val>xmaxval) continue;     
              
              if ( pos == 'd' ) 
              {
                
                vy[0]= ym[0];
                vy[1]= ym[0] + ticksLength ; 
              }
              else 
              { 
                vy[0]= ym[0];
                vy[1]= ym[0] - ticksLength ; 
              }
              if ( ppsubwin->axes.axes_visible[0] )
              {
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
        }
    }
  
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void DrawXTics	(	char	pos,
		sciPointObj *	psubwin,
		double	xy,
		char *	c_format,
		int *	fontid,
		int	textcolor,
		int	ticscolor,
		int	color_kp,
		int *	logrect,
		int	smallersize
	)			[static]

Definition at line 1376 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, AXES::axes_visible, C2F, Cscale, dr(), EPSILON, FALSE, FindXYMinMaxAccordingTL(), foo(), i, iflag, inint, L, sciSubWindow::logflags, Max, AXES::nxgrads, PD0, PI0, pSUBWIN_FEATURE, SAFE_LT, AXES::u_nxgrads, AXES::u_xgrads, AXES::u_xlabels, wcscalelist::WIRect1, XGradPosition(), AXES::xgrads, XScale(), and YScale().

Referenced by SciAxisNew().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval,yminval,xmaxval,ymaxval;
  int  flag=0,xx=0,yy=0,rect[4];
  
  int vx[2],vy[2],xm[2],ym[2];
  int barlength = 0;
  int posi[2];
  double angle=0.0;
  int ns=2,iflag=0;
  
  int nbtics = 0,i;
  char logflag = ppsubwin->logflags[0];

  ym[0] = YScale(xy);
 
  barlength =  Max( (integer) (Cscale.WIRect1[3]/50.0), 2 ) ;
  
  /*ppsubwin->firsttime_x = TRUE;*/
  
  if(ppsubwin->axes.auto_ticks[0] == FALSE)
    {
      /* we display the x tics specified by the user*/
      FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval); /* here i only need x data (ymin ymax are computed but not used after) */
      nbtics = ppsubwin->axes.u_nxgrads;
      
      for(i=0;i<nbtics;i++)
        {
          double xtmp = ppsubwin->axes.u_xgrads[i];
          char *foo = ppsubwin->axes.u_xlabels[i];
          
          if(xtmp<xminval || xtmp>xmaxval) continue; /* cas ou TL est ON et on a des graduations qui ne seront pas affichées de tte facon */
                                                     /* donc autant ne pas aller plus loin dans l'algo... */
          

          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/
          
          C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          /* tick is computed in vx,vy and string is displayed at posi[0],posi[1] position */
          
          vx[0] = vx[1] = xm[0] =  XScale(xtmp);
          posi[0] = inint( xm[0] -rect[2]/2.0);
          
          if ( pos == 'd')
            {
              posi[1]=inint( ym[0] + 1.2*barlength + rect[3]);
              vy[0]= ym[0];vy[1]= ym[0] + barlength ;
            }
          else 
            {
              posi[1]=inint( ym[0] - 1.2*barlength);
              vy[0]= ym[0];vy[1]= ym[0] - barlength;
            }
          
          if ( ppsubwin->axes.axes_visible[0] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&angle, PD0,PD0,PD0,0L,0L);
          }
          XGradPosition(psubwin,posi[1],rect[3]);

          if ( ppsubwin->axes.axes_visible[0] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            /* le tic proprement dit ("petit baton") */
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          
          /***************************************************************/
          /************************* END COMMON PART *********************/
          /***************************************************************/
          
        }
      
    }
  else
    {
      
      FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval); /* here i only need x data (ymin ymax are computed but not used after) */
      nbtics = ppsubwin->axes.nxgrads;
      

      for(i=0;i<nbtics;i++)
        {
          char foo[256]; 
          double xtmp = ppsubwin->axes.xgrads[i];
          
          /* chack that xtmp < xminval || xtmp > xmalval */
          /* but if xtmp is very close to xminval or xmaxval we display it */
          if ( !SAFE_LT( xminval, xtmp, EPSILON ) || !SAFE_LT( xtmp, xmaxval, EPSILON ) )
          {
            continue ;
          }

          sprintf(foo,c_format,xtmp);
          
          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/

          C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          /* tick is computed in vx,vy and string is displayed at posi[0],posi[1] position */
          
          vx[0] = vx[1] = xm[0] =  XScale(xtmp);
          posi[0] = inint( xm[0] -rect[2]/2.0);
          
          if ( pos == 'd')
            {
              posi[1]=inint( ym[0] + 1.2*barlength + rect[3]);
              vy[0]= ym[0];vy[1]= ym[0] + barlength ;
            }
          else 
            {
              posi[1]=inint( ym[0] - 1.2*barlength);
              vy[0]= ym[0];vy[1]= ym[0] - barlength;
            }
          
          if ( ppsubwin->axes.axes_visible[0] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

            
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&angle, PD0,PD0,PD0,0L,0L);
          }
          XGradPosition(psubwin,posi[1],rect[3]);
          if ( logflag == 'l' )
            {
              if ( ppsubwin->axes.axes_visible[0] )
              {
                C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                
                C2F(dr)("xstring","10",(posi[0] -= logrect[2],&posi[0]),
                        (posi[1] += logrect[3],&posi[1]),
                        PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);
              }
              XGradPosition(psubwin,posi[1],rect[3]);
              if ( ppsubwin->axes.axes_visible[0] )
              {
                C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          if ( ppsubwin->axes.axes_visible[0] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            if ( ticscolor != -1 )
            {
              C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            
            /* le tic proprement dit ("petit baton") */
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L); 
            
            if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /***************************************************************/
          /************************* END COMMON PART *********************/
          /***************************************************************/


        }
      

    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

static int DrawYGrid

(

sciPointObj *

psubwin

)

[static]

Definition at line 1679 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, AXES::axes_visible, C2F, dr(), FALSE, FindXYMinMaxAccordingTL(), FREE, sciSubWindow::grid, i, iflag, j, L, sciSubWindow::logflags, MALLOC, AXES::nbsubtics, NULL, AXES::nygrads, pas, PD0, PI0, pSUBWIN_FEATURE, sciprint(), style, AXES::u_nygrads, AXES::u_ygrads, val, XScale(), AXES::ygrads, and YScale().

Referenced by drawAxesGrid().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval,yminval,xmaxval,ymaxval;
  int verbose=0,narg;

  int vx[2],vy[2],xm[2];
  int dash[6],lineMode=2;
  int ns=2,style=0,iflag=0;
  
  double * grads = (double *) NULL;
  int nbtics = 0,i,j;
  int nbsubtics = ppsubwin->axes.nbsubtics[1];
  char logflag = ppsubwin->logflags[1];
   
  FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval);
  
  
  xm[0] = XScale(xminval);
  xm[1] = XScale(xmaxval);

  if(ppsubwin->axes.auto_ticks[1] == FALSE){
    grads =  ppsubwin->axes.u_ygrads;
    nbtics = ppsubwin->axes.u_nygrads;
  }
  else{
    grads =  ppsubwin->axes.ygrads;
    nbtics = ppsubwin->axes.nygrads;
  }
  
  /* Grid style */
  C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F (dr) ("xset", "line style",&lineMode,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  style = ppsubwin->grid[1];
  
  /* Grid based on tics */
  for(i=0;i<nbtics;i++)
    {
      double xtmp = grads[i];
      vy[0] = vy[1] = YScale(xtmp);
      
      if(xtmp<yminval || xtmp>ymaxval) continue;           
      
      vx[0]= xm[0];vx[1]=  xm[1];
      if ( ppsubwin->axes.axes_visible[1] )
      {
        C2F(dr)("xsegs","v", vx, vy, &ns,&style,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
    }
  
  /* Grid based on subtics : ONLY for log. case */
  if(logflag =='l')
    {
      double tmp[2];
      double pas=0;
      double * tmp_log_grads = (double *) NULL;
      
      for(i=0;i<nbtics-1;i++)
        {
          int k;
          tmp[0] = exp10(grads[i]);
          tmp[1] = exp10(grads[i+1]);
          pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );
          
          if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
            sciprint("Error allocating tmp_log_grads\n");
            return -1;
          }
          
          for(k=0;k<nbsubtics;k++) tmp_log_grads[k] = log10(tmp[0]+(k)*pas);
          
          for(j=0;j<nbsubtics;j++)
            {
              double val = tmp_log_grads[j];
              vy[0] = vy[1] = YScale(val);
              
              if(val<yminval || val>ymaxval) continue;    
              
              vx[0]= xm[0];vx[1]=  xm[1];
              if ( ppsubwin->axes.axes_visible[1] )
              {
                C2F(dr)("xsegs","v", vx, vy, &ns,&style,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          
          FREE(tmp_log_grads); tmp_log_grads = NULL;
        }
    }
 

  /* return to solid mode (in default mode) */
  C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int DrawYSubTics	(	char	pos,
		sciPointObj *	psubwin,
		double	xy,
		int	ticscolor,
		int	color_kp
	)			[static]

Definition at line 1558 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, AXES::axes_visible, C2F, Cscale, dr(), dx, FALSE, FindXYMinMaxAccordingTL(), FREE, i, iflag, j, L, sciSubWindow::logflags, MALLOC, Max, AXES::nbsubtics, NULL, AXES::nygrads, pas, PD0, PI0, pSUBWIN_FEATURE, sciprint(), AXES::u_nygrads, AXES::u_ygrads, val, wcscalelist::WIRect1, XScale(), AXES::ygrads, and YScale().

Referenced by SciAxisNew().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval,yminval,xmaxval,ymaxval;

  int vx[2],vy[2],xm[2];
  int barlength = 0;
 int ns=2,iflag=0;
  
  int nbtics = 0,i,j;
  int nbsubtics = ppsubwin->axes.nbsubtics[1];
  char logflag = ppsubwin->logflags[1];
  
  double *grads = (double *) NULL;

  xm[0] = XScale(xy);
   
  barlength =  (integer) (Cscale.WIRect1[2]/75.0);
  
  FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval); /* here i only need x data (ymin ymax are computed but not used after) */
 

  if(ppsubwin->axes.auto_ticks[1] == FALSE){
    grads =  ppsubwin->axes.u_ygrads;
    nbtics = ppsubwin->axes.u_nygrads;
  }
  else{
    grads =  ppsubwin->axes.ygrads;
    nbtics = ppsubwin->axes.nygrads;
  }
  
  
  if(logflag =='l')
    {
      double tmp[2];
      double pas=0;
      double * tmp_log_grads = (double *) NULL;
      
      for(i=0;i<nbtics-1;i++)
        {
          int k;
          tmp[0] = exp10(grads[i]);
          tmp[1] = exp10(grads[i+1]);
          pas = (exp10(grads[i+1]) - exp10(grads[i])) / (nbsubtics );
          
          if((tmp_log_grads = (double *)MALLOC(nbsubtics*sizeof(double)))==NULL){
            sciprint("Error allocating tmp_log_grads\n");
            return -1;
          }
          
          for(k=0;k<nbsubtics;k++) tmp_log_grads[k] = log10(tmp[0]+(k)*pas);
          
          for(j=0;j<nbsubtics;j++)
            {
              double val = tmp_log_grads[j];
              /* the length of the ticks in pixels */
              /* minimum 2 pixels */
              /* use of integer division for speed */
              int ticksLength =  Max( ( 3 * barlength ) / 4,  1 ) ;
              vy[0] = vy[1] = YScale(val);
              
              if(val<yminval || val>ymaxval) continue;     
              
              if ( pos == 'r' ) 
              { 
                vx[0] = xm[0] ;
                vx[1] = xm[0] + ticksLength ; 
              }
              else 
              { 
                vx[0] = xm[0] ;
                vx[1] = xm[0] - ticksLength ; 
              }
              if ( ppsubwin->axes.axes_visible[1] )
              {
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          
          FREE(tmp_log_grads); tmp_log_grads = NULL;
        }
    }
  else
    {
      for(i=0;i<nbtics-1;i++)
        {
          double xtmp = grads[i];
          double dx = (grads[i+1]-grads[i]) / nbsubtics;
          for(j=0;j<nbsubtics;j++)
            {
              double val = xtmp+dx*j;
              /* the length of the ticks in pixels */
              /* minimum 2 pixels */
              /* use of integer division for speed */
              int ticksLength =  Max( ( 3 * barlength ) / 4, 1 ) ;
              vy[0] = vy[1] = YScale(val);
              
              if(val<yminval || val>ymaxval) continue;     
              
              if ( pos == 'r' ) 
              { 
                vx[0] = xm[0] ;
                vx[1]=  xm[0] + ticksLength ; 
              }
              else 
              { 
                vx[0] = xm[0] ;
                vx[1] = xm[0] - ticksLength ; 
              }
              if ( ppsubwin->axes.axes_visible[1] )
              {
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
        }
    }
  
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void DrawYTics	(	char	pos,
		sciPointObj *	psubwin,
		double	xy,
		char *	c_format,
		int *	fontid,
		int	textcolor,
		int	ticscolor,
		int	color_kp,
		int *	logrect,
		int	smallersize
	)			[static]

Definition at line 1779 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, AXES::axes_visible, C2F, Cscale, dr(), EPSILON, FALSE, FindXYMinMaxAccordingTL(), foo(), i, iflag, inint, L, sciSubWindow::logflags, Max, AXES::nygrads, PD0, PI0, pSUBWIN_FEATURE, SAFE_LT, AXES::u_nygrads, AXES::u_ygrads, AXES::u_ylabels, wcscalelist::WIRect1, XScale(), YGradPosition(), AXES::ygrads, and YScale().

Referenced by SciAxisNew().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval,yminval,xmaxval,ymaxval;
  int  flag=0,xx=0,yy=0,rect[4];
  
  int vx[2],vy[2],xm[2],ym[2];
  int barlength = 0;
  int posi[2];
  double angle=0.0;
  int ns=2,iflag=0;
  
  int nbtics = 0,i;
  char logflag = ppsubwin->logflags[1];
  
  xm[0] = XScale(xy); /* F.Leray modified le 28.09.04 */
  
  /* at least 1 pixels */
  barlength =  Max( (integer) (Cscale.WIRect1[2]/75.0), 2 ) ;
  

  if(ppsubwin->axes.auto_ticks[1] == FALSE)
    {
      /* we display the x tics specified by the user*/
      FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval); /* here i only need y data (xmin xmax are computed but not used after) */
      nbtics = ppsubwin->axes.u_nygrads;
      
      for(i=0;i<nbtics;i++)
        {
          double ytmp = ppsubwin->axes.u_ygrads[i];
          char *foo = ppsubwin->axes.u_ylabels[i];
          
          if(ytmp<yminval || ytmp>ymaxval) continue; /* cas ou TL est ON et on a des graduations qui ne seront pas affichées de tte facon */
                                                     /* donc autant ne pas aller plus loin dans l'algo... */


          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/
          
          C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          /* tick is computed in vx,vy and string is displayed at posi[0],posi[1] position */
          
          vy[0]= vy[1] = ym[0] = YScale(ytmp);
          posi[1]=inint( ym[0] +rect[3]/2.0);
          if ( pos == 'r' ) 
            {
              posi[0]=inint( xm[0] + 1.2*barlength);
              vx[0]= xm[0];vx[1]= xm[0]+barlength;
            }
          else 
            { 
              posi[0]=inint(xm[0] - 1.2*barlength - rect[2]);
              vx[0]= xm[0];vx[1]= xm[0] - barlength;
            }




          if ( ppsubwin->axes.axes_visible[1] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&angle, PD0,PD0,PD0,0L,0L);
          }
          YGradPosition(psubwin,posi[0],rect[2]);

          if ( ppsubwin->axes.axes_visible[1] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          
          /***************************************************************/
          /************************* END COMMON PART *********************/
          /***************************************************************/
          
        }
    }
  else
    {

      FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval); /* here i only need y data (xmin xmax are computed but not used after) */
      nbtics = ppsubwin->axes.nygrads;
      
      for(i=0;i<nbtics;i++)
        {
          char foo[256];
          double ytmp = ppsubwin->axes.ygrads[i];
          
          
          /* chack that xtmp < xminval || xtmp > xmalval */
          /* but if xtmp is very close to xminval or xmaxval we display it */
          if ( !SAFE_LT( yminval, ytmp, EPSILON ) || !SAFE_LT( ytmp, ymaxval, EPSILON ) )
          {
            continue ;
          }

          sprintf(foo,c_format,ytmp);
          
          
          /***************************************************************/
          /************************* COMMON PART *************************/
          /***************************************************************/
          
          C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          /* tick is computed in vx,vy and string is displayed at posi[0],posi[1] position */

          vy[0]= vy[1] = ym[0] = YScale(ytmp);
          posi[1]=inint( ym[0] +rect[3]/2.0);

          if ( pos == 'r' ) 
            {
              posi[0]=inint( xm[0] + 1.2*barlength);
              vx[0]= xm[0];vx[1]= xm[0]+barlength;
            }
          else 
            { 
              posi[0]=inint(xm[0] - 1.2*barlength - rect[2]);
              vx[0]= xm[0];vx[1]= xm[0] - barlength;
            }
          
          
          if ( ppsubwin->axes.axes_visible[1] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&angle, PD0,PD0,PD0,0L,0L);
          }
          YGradPosition(psubwin,posi[0],rect[2]);
          
          if ( logflag == 'l' )
            {
              if ( ppsubwin->axes.axes_visible[1] )
              {
                C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
                
                C2F(dr)("xstring","10",(posi[0] -= logrect[2],&posi[0]),
                        (posi[1] += logrect[3],&posi[1]),
                        PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);
              }
              YGradPosition(psubwin,posi[0],rect[2]); /* adding F.Leray 04.08.05 */
              if ( ppsubwin->axes.axes_visible[1] )
              {
                C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }
            }
          if ( ppsubwin->axes.axes_visible[1] )
          {
            if ( textcolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            
            C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          
            if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
          /***************************************************************/
          /************************* END COMMON PART *********************/
          /***************************************************************/
          
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void findFormat	(	sciPointObj *	pSubWin,
		char	formatX[5],
		char	formatY[5]
	)

Definition at line 2752 of file Axes.c.

References sciSubWindow::axes, ChoixFormatE(), Max, AXES::nxgrads, AXES::nygrads, pSUBWIN_FEATURE, AXES::xgrads, and AXES::ygrads.

Referenced by SciAxisNew(), updateXaxesTics(), and updateYaxesTics().

{
  sciSubWindow * ppSubWin = pSUBWIN_FEATURE( pSubWin ) ;
  int lastIndex ;

  /* x axis */
  lastIndex = Max( ppSubWin->axes.nxgrads - 1, 0 ) ;

  ChoixFormatE( formatX,
                ppSubWin->axes.xgrads[0],
                ppSubWin->axes.xgrads[lastIndex],
               ( (ppSubWin->axes.xgrads[lastIndex])-(ppSubWin->axes.xgrads[0]))/(lastIndex)); /* Adding F.Leray 06.05.04 */

  /* y-axis */
  lastIndex = Max( ppSubWin->axes.nygrads - 1, 0 ) ;
  
  ChoixFormatE( formatY,
                ppSubWin->axes.ygrads[0],
                ppSubWin->axes.ygrads[lastIndex],
                ((ppSubWin->axes.ygrads[lastIndex])-(ppSubWin->axes.ygrads[0]))/(lastIndex)); /* Adding F.Leray 06.05.04 */
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void FindXYMinMaxAccordingTL	(	sciPointObj *	psubwin,
		double *	xminval,
		double *	yminval,
		double *	xmaxval,
		double *	ymaxval
	)			[static]

Definition at line 1986 of file Axes.c.

References sciSubWindow::axes, pSUBWIN_FEATURE, AXES::xlim, and AXES::ylim.

Referenced by checkXAxes2dTics(), checkYAxes2dTics(), DrawXGrid(), DrawXSubTics(), DrawXTics(), DrawYGrid(), DrawYSubTics(), DrawYTics(), SciAxisNew(), and SciDrawLines().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  
  *xminval = ppsubwin->axes.xlim[0];
  *yminval = ppsubwin->axes.ylim[0];
  
  *xmaxval = ppsubwin->axes.xlim[1];
  *ymaxval = ppsubwin->axes.ylim[1];
}

Here is the caller graph for this function:

void getTicksLabelBox	(	double	fact_h,
		double	fact_w,
		char *	label,
		int	pos[2],
		int	fontId[2],
		char	logflag,
		int	bbox[4],
		BOOL	changeFont
	)

Definition at line 2332 of file Axes.c.

References C2F, dr(), int, L, PD0, and PI0.

Referenced by CheckDisplay(), checkXAxes2dTics(), and checkYAxes2dTics().

{  
  int prevFontId[2] ;
  
  if ( changeFont )
  {
    int verbose = 0 ;
    int narg ;
    C2F(dr)("xget","font",&verbose,prevFontId,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
    C2F(dr)("xset","font",fontId,fontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
  }
  
  if ( logflag == 'n' )
  { 
    C2F(dr)("xstringl",label,&pos[0],&pos[1],bbox,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    bbox[3] = (int)(fact_h * bbox[3]);
    bbox[2] = (int)(fact_w * bbox[2]);
  }
  else
  {
    int smallersize = fontId[1]-2;
    int rect10[4];
    int posi10[2];
    int logrect[4] ;
    int XX = 1 ;
    int YY = 1 ;
    /* compute bounding of "10"  string used for log scale ON and auto_ticks ON */
    C2F(dr)("xstringl","10",&XX,&YY,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
    
    posi10[0] = pos[0] - logrect[2];
    posi10[1] = pos[1] + logrect[3];
    
    /* get the bbox of the 10 */
    C2F(dr)("xstringl","10",(&posi10[0]),(&posi10[1]),rect10,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    
    pos[0] = rect10[0] + rect10[2];
    pos[1] = (int) (rect10[1] - rect10[3]*.1);
    
    C2F(dr)("xset","font",fontId,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    
    /* get the bbox of the exponent */
    C2F(dr)("xstringl",label,(&pos[0]),(&pos[1]),bbox,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    
    bbox[2] = (integer)(fact_w*(bbox[2] + rect10[2]));
    bbox[3] = (integer)(fact_h*(bbox[3] + rect10[3] + (int) (rect10[3]*.1))); /* added the 01.06.05 */
    bbox[0] = rect10[0];
    /* bbox[1] = bbox[1]; */
    
    C2F(dr)("xset","font",fontId,fontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }

  if ( changeFont )
  {
    C2F(dr)("xset","font",prevFontId,prevFontId+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void initSubWinAngles

(

sciPointObj *

pSubWin

)

Definition at line 2197 of file Axes.c.

References sciSubWindow::alpha, sciSubWindow::alpha_kp, getAxesModel(), sciSubWindow::is3d, pSUBWIN_FEATURE, sciSubWindow::theta, and sciSubWindow::theta_kp.

Referenced by reinitSubWin().

{
  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin ) ;
  sciSubWindow * ppAxesMdl = pSUBWIN_FEATURE (getAxesModel()) ;
  ppSubWin->is3d     = ppAxesMdl->is3d     ;
  ppSubWin->alpha_kp = ppAxesMdl->alpha_kp ;
  ppSubWin->theta_kp = ppAxesMdl->theta_kp ;
  ppSubWin->alpha    = ppAxesMdl->alpha    ;
  ppSubWin->theta    = ppAxesMdl->theta    ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void initSubWinBounds

(

sciPointObj *

pSubWin

)

Definition at line 2222 of file Axes.c.

References sciSubWindow::FRect, getAxesModel(), pSUBWIN_FEATURE, and sciSubWindow::SRect.

Referenced by reinitSubWin().

{
  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin ) ;
  sciSubWindow * ppAxesMdl = pSUBWIN_FEATURE (getAxesModel()) ;
  ppSubWin->FRect[0] = ppAxesMdl->FRect[0] ;
  ppSubWin->FRect[1] = ppAxesMdl->FRect[1] ;
  ppSubWin->FRect[2] = ppAxesMdl->FRect[2] ;
  ppSubWin->FRect[3] = ppAxesMdl->FRect[3] ;
  ppSubWin->FRect[4] = ppAxesMdl->FRect[4] ;
  ppSubWin->FRect[5] = ppAxesMdl->FRect[5] ;

  ppSubWin->SRect[0] = ppAxesMdl->SRect[0] ;
  ppSubWin->SRect[1] = ppAxesMdl->SRect[1] ;
  ppSubWin->SRect[2] = ppAxesMdl->SRect[2] ;
  ppSubWin->SRect[3] = ppAxesMdl->SRect[3] ;
  ppSubWin->SRect[4] = ppAxesMdl->SRect[4] ;
  ppSubWin->SRect[5] = ppAxesMdl->SRect[5] ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void initSubWinSize

(

sciPointObj *

pSubWin

)

Definition at line 2210 of file Axes.c.

References getAxesModel(), pSUBWIN_FEATURE, and sciSubWindow::WRect.

Referenced by initsubwin().

{
  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin ) ;
  sciSubWindow * ppAxesMdl = pSUBWIN_FEATURE (getAxesModel()) ;
  ppSubWin->WRect[0] = ppAxesMdl->WRect[0] ;
  ppSubWin->WRect[1] = ppAxesMdl->WRect[1] ;
  ppSubWin->WRect[2] = ppAxesMdl->WRect[2] ;
  ppSubWin->WRect[3] = ppAxesMdl->WRect[3] ;

}

Here is the call graph for this function:

Here is the caller graph for this function:

BOOL IsInsideRectangle	(	int *	rect,
		int *	point
	)

Definition at line 2318 of file Axes.c.

References FALSE, and TRUE.

{

  if((point[0] >= rect[0] && point[0] <= rect[0]+rect[2]) &&
     (point[1] >= rect[1] && point[1] <= rect[1]+rect[3]))
    return FALSE;
  
  return TRUE;
}

int labels2D_draw

(

sciPointObj *

psubwin

)

Definition at line 3036 of file Axes.c.

References sciLabel::auto_position, sciLabel::auto_rotation, sciSubWindow::axes, computeLabelAutoPos(), Cscale, drawTextEntity(), sciSubWindow::mon_title, sciSubWindow::mon_x_label, sciSubWindow::mon_y_label, offset, pLABEL_FEATURE, pSUBWIN_FEATURE, sciGetVisibility(), sciInitFontOrientation(), sciSetFontOrientation(), sciLabel::text, wcscalelist::WIRect1, AXES::xdir, sciSubWindow::XGradMostOnBottom, sciSubWindow::XGradMostOnTop, AXES::ydir, sciSubWindow::YGradMostOnLeft, and sciSubWindow::YGradMostOnRight.

Referenced by drawSubWinEntity().

{
  /* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rebuild_strflag	(	sciPointObj *	psubwin,
		char *	STRFLAG
	)

Definition at line 2985 of file Axes.c.

References sciSubWindow::axes, BT_ON, GetIsAxes2D(), pSUBWIN_FEATURE, AXES::rect, sciSubWindow::tight_limits, TRUE, AXES::xdir, and AXES::ydir.

Referenced by DrawAxes(), and drawSubWinEntity().

{

  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';
}

Here is the call graph for this function:

Here is the caller graph for this function:

void reinitSubWin

(

sciPointObj *

pSubWin

)

Definition at line 2175 of file Axes.c.

References sciSubWindow::axes, clearSubWin(), sciSubWindow::FirstPlot, initSubWinAngles(), initSubWinBounds(), pSUBWIN_FEATURE, sciSubWindow::surfcounter, TRUE, sciSubWindow::visible, AXES::xdir, and AXES::ydir.

Referenced by checkRedrawing(), and initsubwin().

{
  sciSubWindow * ppSubWin  = pSUBWIN_FEATURE (pSubWin) ;
  
  clearSubWin(   pSubWin ) ;
 
  initSubWinBounds( pSubWin ) ;
  ppSubWin->axes.xdir = 'd' ;
  ppSubWin->axes.ydir = 'l' ;
  
  ppSubWin->visible = TRUE;
  
  initSubWinAngles( pSubWin ) ;
  
  ppSubWin->surfcounter = 0 ;
  
  ppSubWin->FirstPlot = TRUE;
  

}

Here is the call graph for this function:

Here is the caller graph for this function:

void removeBadTicks	(	double *	ticks,
		BOOL *	removedTicks,
		int *	nbTicks
	)

Definition at line 2723 of file Axes.c.

References i, and removeIndex().

Referenced by GradFixedlog().

{
  int i ;
  for ( i = *nbTicks - 1 ; i >= 0 ; i-- )
  {
    if ( removedTicks[i] )
    {
      removeIndex( ticks, *nbTicks, i ) ;
      *nbTicks = *nbTicks - 1 ;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void removeIndex	(	double *	changedArray,
		int	size,
		int	ind
	)

Definition at line 2740 of file Axes.c.

References i.

Referenced by removeBadTicks().

{
  int i ;
  for ( i = ind + 1 ; i < size ; i++ )
  {
    changedArray[i-1] = changedArray[i] ;
  } 
}

Here is the caller graph for this function:

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
	)

Definition at line 224 of file Axes.c.

References C2F, ChoixFormatE(), ChoixFormatE1(), Cscale, dr(), dx, dy, foo(), wcscalelist::frect, i, iflag, inint, int, j, L, NULL, pas, PD0, PI0, pSUBWIN_FEATURE, sciGetCurrentSubWin(), sciprint(), TRUE, wcscalelist::Waaint1, wcscalelist::WIRect1, x_convert(), XScale(), wcscalelist::xtics, y_convert(), YScale(), and wcscalelist::ytics.

Referenced by drawAxesEntity().

{
  int Nx,Ny,j;
  double angle=0.0,vxx,vxx1;
  int vx[2],vy[2],xm[2],ym[2];
  char c_format[5];
  integer flag=0,xx=0,yy=0,posi[2],rect[4],dash[6],trois=3;
  integer i,barlength;
  int ns=2,iflag=0;
  integer fontid[2],fontsize_kp, narg,verbose=0,logrect[4],smallersize,color_kp; 
  integer pstyle;
  int x3, y3, xpassed = 0, ypassed = 0; /* for log. case management */
  /*** 01/07/2002 -> 11.05.04 ***/ /* F.Leray : Re-put the Djalel modif. for a better display 
                                   using tight_limits='on' and/or isoview='on' */
  double xmin,xmax,ymin, ymax; 
  sciPointObj * psubwin = NULL;
  double pas; /* used for logarithmic grid */

  fontid[0]= fontstyle;

  psubwin = sciGetCurrentSubWin();

  C2F(dr)("xget","font",&verbose,fontid,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  fontsize_kp = fontid[1] ;
  if ( fontsize == -1 )
  {
    fontid[0]= 0; fontid[1]= 1;  fontsize_kp = fontid[1] ;
    fontid[0]= fontstyle;
    C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }

  if ( fontsize != -1 ) 
  {
    fontid[1] = fontsize ;
    fontid[0]= fontstyle;
    C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }
  if ( textcolor != -1 || ticscolor != -1 ) 
  {
    C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }

  if (logflag == 'l' )
  {
    C2F(dr)("xstringl","10",&xx,&yy,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L); 
    smallersize=fontid[1]-2;
    C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  }


  /* Pb here, dim of x and y can be lesser than 4 (ie in example_eng.tst : nx = 6 and ny = 1) F.Leray 25.02.04
  x and y are either double x[3] (resp. y[3]) or simply a double !  F.Leray 05.03.04
  So a test on x[3] (resp. y[3]) is ALWAYS bad!!
  NO!! It depends on the xy_type as follow */
  /*
  *   xy_type = 'v' (for vector) or 'r' (for range) 
  *         'v' means that tics position are given by a vector 
  *         'r' means that tics position are in a range i.e given by a vector of size 3 
  *             [min,max,number_of_intervals] 
  *         'i' means that tics positions are in a range given by four number (integers) 
  *             [k1,k2,e,number_of intervals] -> [k1*10^e,k2*10^e] */

  if(xy_type == 'i')
  {     /* Adding F.Leray 05.03.04*/
    /*F.Leray Modification on 09.03.04*/
    switch ( pos ) {
      case 'u' : case 'd' :  
        if(pSUBWIN_FEATURE(psubwin)->logflags[0] == 'n')
          while (x[3]>10)  x[3]=floor(x[3]/2); 
        else{
          if(x[3] > 12){ /* F.Leray arbitrary value=12 for the moment */
            x3=(int)x[3];     /* if x[3]>12 algo is triggered to search a divisor */
            for(j=x3-1;j>1;j--)
            {
              if(x3%j == 0){
                x[3]=j; 
                xpassed = 1;
              }
            }
            if(xpassed != 1) { x[3] = 1; }
          }
        }

        break;
      case 'r' : case 'l' :
        if(pSUBWIN_FEATURE(psubwin)->logflags[1] == 'n')
          while (y[3]>10)  y[3]=floor(y[3]/2);
        else{
          if(y[3] > 12){
            y3=(int)y[3];
            for(j=y3-1;j>1;j--)
              if(y3%j == 0){
                y[3]=j;
                ypassed = 1;
              }
              if(ypassed != 1) y[3] = 1;
          }

          break;
        }
    }


  }


  switch ( xy_type ) 
  {
  case 'v' : Nx= *nx; Ny= *ny; break;
  case 'r' :
    switch ( pos ) {
  case 'u' : case 'd' : Nx = (int) x[2]+1; break;
  case 'r' : case 'l' : Ny = (int) y[2]+1; break;
    }
    break;
  case 'i' : 
    switch ( pos ) {
  case 'u' : case 'd' : Nx = (int) x[3]+1; break; 
  case 'r' : case 'l' : Ny = (int) y[3]+1; break;
    }
    break;
  default: 
    sciprint("Sci_Axis: wrong type argument xy_type\r\n");
  }
  switch (pos ) 
  {
  case 'u' : 
  case 'd' :
    barlength =  (integer) (Cscale.WIRect1[3]/50.0);
    if (str == NULL && format == NULL )  
      switch (xy_type ) {
  case 'v' : ChoixFormatE1(c_format,x,Nx);break;
  case 'r' : ChoixFormatE (c_format,x[0],x[1],(x[1]-x[0])/x[2]);break;
  case 'i' : 
    ChoixFormatE (c_format,
      (x[0] * exp10(x[2])),
      (x[1] * exp10(x[2])),
      ((x[1] * exp10(x[2])) - (x[0] * exp10(x[2])))/x[3]); break; /* Adding F.Leray 06.05.04 */
    }
    vx[0] =  XScale(x_convert(xy_type, x , 0)); /* C EST LA que se calcule les positions initiales et finales (en x et y) de la barre support de l'axe des abscisses */
    vx[1] =  XScale(x_convert(xy_type, x , Nx-1));
    vy[0]= vy[1] = ym[0] = YScale(y[0]);
    if ( seg_flag == 1) 
    {
      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
    /******* 01/07/2002  -> 11.05.04 **********/
    psubwin = sciGetCurrentSubWin();
    if ((pSUBWIN_FEATURE (psubwin)->tight_limits == TRUE || pSUBWIN_FEATURE (psubwin)->isoview == TRUE )
      && axisbuild_flag == 0){{ 
        xmax=Cscale.frect[2];
        xmin=Cscale.frect[0];

        if(xy_type == 'i')
        {


          x[1] = floor(  Cscale.xtics[1] );
          x[0] =  ceil(  Cscale.xtics[0] );
          x[3]=inint(x[1]-x[0]);
          while (x[3]>10)  x[3]=floor(x[3]/2);
          Nx=(int)(x[3]+1);

          /* re-compute a format when tight_limits or isoview == ON */
          ChoixFormatE (c_format,
            (x[0] * exp10(x[2])),
            (x[1] * exp10(x[2])),
            ((x[1] * exp10(x[2])) - (x[0] * exp10(x[2])))/x[3]); /* Adding F.Leray 15.05.04 */
        }
        /* THESE 2 last cases are unreachable because we use the condition : */
        /* axisbuild_flag == 0 */
        else if (xy_type == 'r') /* normally unreachable */
        {
          sciprint(" Normally, unreachable case \n");
        }
        else if(xy_type == 'v') /* normally unreachable */
        {
          sciprint(" Normally, unavailable case  AAA \n");
        }
    }


    pas = ((double) Cscale.WIRect1[2]) / ((double) Cscale.Waaint1[1]);

    /**********************/
    if (Nx==1) break;
    for (i=0 ; i < Nx ; i++)
    {  
      char foo[100];
      vxx = x_convert(xy_type,x,i);
      if ( str != NULL)  
        sprintf(foo,"%s",str[i]);
      else if ( format == NULL) 
      {
        /* defaults format */
        /*F.Leray 19.05.04 */
        /* When Sci_Axis is called by aplotv1, format is NULL : it can not be something else...*/
        /* format can also be NULL if non specified and coming from ConstructAxes method called in Objdrawaxis (see matdes.c) */
        sprintf(foo,c_format,vxx);
      }
      else {
        sprintf(foo,format,vxx);
      }


      C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

      /* tick is computed in vx,vy and string is displayed at posi[0],posi[1] position */

      vx[0] = vx[1] = xm[0] =  XScale(vxx);
      posi[0] = inint( xm[0] -rect[2]/2.0);

      if ( pos == 'd' ) 
      {
        posi[1]=inint( ym[0] + 1.2*barlength + rect[3]);
        vy[0]= ym[0];vy[1]= ym[0] + barlength ;
      }
      else 
      { 
        posi[1]=inint( ym[0] - 1.2*barlength);
        vy[0]= ym[0];vy[1]= ym[0] - barlength;
      }
      if ( textcolor != -1 ) C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&angle, PD0,PD0,PD0,0L,0L);
      if ( logflag == 'l' )
      {
        C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
        C2F(dr)("xstring","10",(posi[0] -= logrect[2],&posi[0]),
          (posi[1] += logrect[3],&posi[1]),
          PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);
        C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
      if ( textcolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);

      /*** MAJ Djalel.A 21/01/2003 ***/ 
      if (pSUBWIN_FEATURE (psubwin)->grid[0] > -1) 
      { 
        if(pSUBWIN_FEATURE (psubwin)->logflags[0] == 'l')
        {
          if ((vx[0] != Cscale.WIRect1[0]) && (vx[0] != (Cscale.WIRect1[0]+ Cscale.WIRect1[2])))
          {
            pstyle=pSUBWIN_FEATURE (psubwin)->grid[0] ;
            C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F (dr) ("xset", "line style",&trois,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            vy[0]=Cscale.WIRect1[1];
            vy[1]=Cscale.WIRect1[1]+Cscale.WIRect1[3];  
            C2F(dr)("xsegs","v", vx, vy, &ns,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }

          if(i < Nx -1 )
          {
            int jinit=1;
            /* In case there is a log. scale, add. sub-grid taking account of this special scale F.Leray 07.05.04 */
            pstyle=pSUBWIN_FEATURE (psubwin)->grid[0] ;
            C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F (dr) ("xset", "line style",&trois,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            vy[0]=Cscale.WIRect1[1];
            vy[1]=Cscale.WIRect1[1]+Cscale.WIRect1[3];

            if ( i== 0 ) jinit=2; /* no grid on plot boundary */
            for (j= jinit; j < 10 ; j++)
            {
              vx[0]=vx[1]= Cscale.WIRect1[0] + inint( ((double) i)*pas)+ inint(log10(((double)j))*pas);
              C2F(dr)("xsegs","v", vx, vy, &ns,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L) ;
          }
        }
        else if(pSUBWIN_FEATURE (psubwin)->logflags[0] == 'n')
        {
          if ((vx[0] != Cscale.WIRect1[0]) && (vx[0] != (Cscale.WIRect1[0]+ Cscale.WIRect1[2])))
          {
            pstyle=pSUBWIN_FEATURE (psubwin)->grid[0] ;
            C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F (dr) ("xset", "line style",&trois,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            vy[0]=Cscale.WIRect1[1];
            vy[1]=Cscale.WIRect1[1]+Cscale.WIRect1[3];  
            C2F(dr)("xsegs","v", vx, vy, &ns,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
        }
      }
      /***/
      /* subtics */
      if ( i < Nx-1 ) 
      {
        double dx ; 
        vxx1= x_convert(xy_type,x,i+1);
        dx = (vxx1-vxx)/subtics;
        for ( j = 1 ; j < subtics; j++){ 
          vx[0] = vx[1] = XScale(vxx+dx*j);
          if ( pos == 'd' ) 
          { vy[0]= ym[0];vy[1]=  (integer) (ym[0] + barlength/2.0) ; }
          else 
          { vy[0]= ym[0];vy[1]=  (integer) (ym[0] - barlength/2.0) ; }
          C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
        }
      } 
      /***   01/07/2002  -> 11.05.04 ****/
      psubwin = sciGetCurrentSubWin();
      if ( (pSUBWIN_FEATURE (psubwin)->tight_limits || pSUBWIN_FEATURE (psubwin)->isoview )
        && axisbuild_flag == 0)
      {  
        if ( i == 0 ) 
        {
          double dx ; 
          vxx1= x_convert(xy_type,x,i+1);
          dx = (vxx1-vxx)/subtics;
          for ( j = 1 ; j < subtics; j++) {  
            if ( vxx-dx*j > xmin){
              vx[0] = vx[1] = XScale(vxx-dx*j);
              if ( pos == 'd' ) 
              { vy[0]= ym[0];vy[1]=(int) (ym[0] + barlength/2.0) ; }
              else 
              { vy[0]= ym[0];vy[1]= (int)(ym[0] - barlength/2.0); }
              C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }}
        } 
        if ( i == Nx-1 ) 
        {
          double dx ; 
          vxx1= x_convert(xy_type,x,i+1);
          dx = (vxx1-vxx)/subtics;
          for ( j = 1 ; j < subtics; j++) {  
            if ( vxx+dx*j < xmax){
              vx[0] = vx[1] = XScale(vxx+dx*j);
              if ( pos == 'd' ) 
              { vy[0]= ym[0];vy[1]= (int)(ym[0] + barlength/2.0) ; }
              else 
              { vy[0]= ym[0];vy[1]= (int)(ym[0] - barlength/2.0); }
              C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }}
        } 
      }
      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
    break;
  case 'r' : 
  case 'l' :

    barlength =  (integer) (Cscale.WIRect1[2]/75.0);
    if (str == NULL &&  format == NULL )  
      switch (xy_type ) {
  case 'v' : ChoixFormatE1(c_format,y,Ny);break;
  case 'r' : ChoixFormatE(c_format,y[0],y[1],(y[1]-y[0])/y[2]);break;
  case 'i' : 
    ChoixFormatE (c_format,
      (y[0] * exp10(y[2])),
      (y[1] * exp10(y[2])),
      ((y[1] * exp10(y[2])) - (y[0] * exp10(y[2])))/y[3]); break; /* Adding F.Leray 06.05.04 */
    }
    vy[0] =  YScale(y_convert(xy_type, y , 0));
    vy[1] =  YScale(y_convert(xy_type, y , Ny-1));
    vx[0]= vx[1] = xm[0]= XScale(x[0]);
    if ( seg_flag == 1) 
    {
      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }

    /***   01/07/2002 -> 11 and 12.05.04 ****/
    psubwin = sciGetCurrentSubWin();
    if ((pSUBWIN_FEATURE (psubwin)->tight_limits == TRUE || pSUBWIN_FEATURE (psubwin)->isoview == TRUE )
      && axisbuild_flag == 0){  
        ymax=Cscale.frect[3];
        ymin=Cscale.frect[1];

        if(xy_type == 'i')
        {
          /*   y[1] = floor(Cscale.frect[3] / (exp10( y[2]))) ;   */
          /*        y[0] =  ceil(Cscale.frect[1]  / (exp10( y[2]))) ;  */

          y[1] = floor( Cscale.ytics[1] );
          y[0] =  ceil( Cscale.ytics[0] );

          y[3]=inint(y[1]-y[0]);
          while (y[3]>10)  y[3]=floor(y[3]/2);
          Ny=(int)(y[3]+1);

          /* re-compute a format when tight_limits or isoview == ON */
          ChoixFormatE (c_format,
            (y[0] * exp10(y[2])),
            (y[1] * exp10(y[2])),
            ((y[1] * exp10(y[2])) - (y[0] * exp10(y[2])))/y[3]);
        }
        /* THESE 2 last cases are unreachable because we use the condition : */
        /* axisbuild_flag == 0 */
        else if (xy_type == 'r') /* normally unreachable */
        {
          sciprint(" Normally, unreachable case \n");
        }
        else if(xy_type == 'v')  /* normally unreachable */
        {
          sciprint(" Normally, unreachable case \n");
        }
    }



    pas = ((double) Cscale.WIRect1[3]) / ((double) Cscale.Waaint1[3]);
    if (Ny==1) break; /*D.Abdemouche 16/12/2003*/
    for (i=0 ; i < Ny ; i++)
    { 
      char foo[100];
      vxx = y_convert(xy_type,y,i);
      if ( str != NULL)  
        sprintf(foo,"%s",str[i]);
      else if ( format == NULL)
      { 
        /* defaults format */
        /*F.Leray 19.05.04 */
        /* When Sci_Axis is called by aplotv1, format is NULL : it can not be something else...*/
        /* format can also be NULL if non specified and coming from ConstructAxes method called in Objdrawaxis (see matdes.c) */
        sprintf(foo,c_format,vxx);
      }
      else{ 
        sprintf(foo,format,vxx);
      }


      C2F(dr)("xstringl",foo,&xx,&yy,rect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

      /* tick is computed in vx,vy and string is displayed at posi[0],posi[1] position */

      vy[0]= vy[1] = ym[0] = YScale(vxx);
      posi[1]=inint( ym[0] +rect[3]/2.0);
      if ( pos == 'r' ) 
      {
        posi[0]=inint( xm[0] + 1.2*barlength);
        vx[0]= xm[0];vx[1]= xm[0]+barlength;
      }
      else 
      { 
        posi[0]=inint(xm[0] - 1.2*barlength - rect[2]);
        vx[0]= xm[0];vx[1]= xm[0] - barlength;
      }
      if ( textcolor != -1 ) C2F(dr)("xset","pattern",&textcolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xstring",foo,&(posi[0]),&(posi[1]),PI0,&flag,PI0,PI0,&angle, PD0,PD0,PD0,0L,0L);
      if ( logflag == 'l' )
      {
        C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
        C2F(dr)("xstring","10",(posi[0] -= logrect[2],&posi[0]),
          (posi[1] += logrect[3],&posi[1]),
          PI0,&flag,PI0,PI0,&angle,PD0,PD0,PD0,0L,0L);
        C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      }
      if ( textcolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);

      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
      C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
      /*** MAJ Djalel.A 21/01/2003 ***/ 
      if (pSUBWIN_FEATURE (psubwin)->grid[1] > -1 )
      { 
        if(pSUBWIN_FEATURE (psubwin)->logflags[1] == 'l')
        {
          if ((vy[0] != Cscale.WIRect1[1]) && (vy[0] != (Cscale.WIRect1[1]+ Cscale.WIRect1[3])))
          {
            pstyle=pSUBWIN_FEATURE (psubwin)->grid[1] ;
            vx[0]=Cscale.WIRect1[0];
            vx[1]=Cscale.WIRect1[0]+Cscale.WIRect1[2];  
            C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F (dr) ("xset", "line style",&trois,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xsegs","v", vx, vy, &ns,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }

          if(i < Ny -1 ){
            int jinit=1;
            /* In case there is a log. scale, add. sub-grid taking account of this special scale F.Leray 07.05.04 */
            pstyle=pSUBWIN_FEATURE (psubwin)->grid[1] ;
            C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F (dr) ("xset", "line style",&trois,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            vx[0]=Cscale.WIRect1[0];
            vx[1]=Cscale.WIRect1[0]+Cscale.WIRect1[2]; 

            if ( i== Cscale.Waaint1[3]-1 ) jinit=2; /* no grid on plot boundary */
            for (j= jinit; j < 10 ; j++)
            {
              vy[0]=vy[1]= Cscale.WIRect1[1] + inint( ((double) i+1)*pas)- inint(log10(((double)j))*pas);
              C2F(dr)("xsegs","v", vx, vy, &ns,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            }
            C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
        }
        else  if(pSUBWIN_FEATURE (psubwin)->logflags[1] == 'n'){
          if ((vy[0] != Cscale.WIRect1[1]) && (vy[0] != (Cscale.WIRect1[1]+ Cscale.WIRect1[3])))
          {
            pstyle=pSUBWIN_FEATURE (psubwin)->grid[1] ;
            vx[0]=Cscale.WIRect1[0];
            vx[1]=Cscale.WIRect1[0]+Cscale.WIRect1[2];  
            C2F(dr)("xget","line style",&verbose,dash,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F (dr) ("xset", "line style",&trois,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xsegs","v", vx, vy, &ns,&pstyle,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
            C2F(dr)("xset","line style",dash,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          }
        }
      }
      /* subtics */
      if ( i < Ny-1 ) 
      {
        double dy ; 
        vxx1= y_convert(xy_type,y,i+1);
        dy = (vxx1-vxx)/subtics;
        for ( j = 1 ; j < subtics; j++) 
        {
          vy[0] = vy[1] = YScale(vxx+dy*j);
          if ( pos == 'r' ) 
          { vx[0]= xm[0];vx[1]= (integer) (xm[0] + barlength/2.0) ; }
          else 
          { vx[0]= xm[0];vx[1]= (integer) (xm[0] - barlength/2.0) ; }
          C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
        }
      }
      /***   01/07/2002 -> 12.05.04 ****/
      psubwin = sciGetCurrentSubWin();
      if ( (pSUBWIN_FEATURE (psubwin)->tight_limits == TRUE || pSUBWIN_FEATURE (psubwin)->isoview == TRUE )
        && axisbuild_flag == 0){
          if ( i == 0 )  
          {
            double dy ; 
            vxx1= y_convert(xy_type,y,i+1);
            dy = (vxx1-vxx)/subtics;
            for ( j = 1 ; j < subtics; j++) {  
              if ( vxx-dy*j > ymin){
                vy[0] = vy[1] = YScale(vxx-dy*j);
                if ( pos == 'r' ) 
                { vx[0]= xm[0];vx[1]= (int)(xm[0] + barlength/2.0) ; }
                else 
                { vx[0]= xm[0];vx[1]= (int) (xm[0] - barlength/2.0); }
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }}
          }
          if ( i == Ny-1 )
          {
            double dy ; 
            vxx1= y_convert(xy_type,y,i+1);
            dy = (vxx1-vxx)/subtics;
            for ( j = 1 ; j < subtics; j++) {  
              if ( vxx+dy*j < ymax){
                vy[0] = vy[1] = YScale(vxx+dy*j);
                if ( pos == 'r' ) 
                { vx[0]= xm[0];vx[1]= (int)(xm[0] + barlength/2.0) ; }
                else 
                { vx[0]= xm[0];vx[1]= (int)(xm[0] - barlength/2.0); }
                C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
              }}
          }  
      }
      if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
    break;
    }
    /* reset font to its current size */ 
    if ( fontsize != -1 || logflag == 'l' )
    {
      fontid[1] = fontsize_kp;
      C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
    /* reset to current color */
    if ( textcolor != -1 || ticscolor != -1 ) 
    {
      C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }

  }

} 

Here is the call graph for this function:

Here is the caller graph for this function:

static int SciAxisNew	(	char	pos,
		sciPointObj *	psubwin,
		double	xy,
		int	fontsize,
		int	fontstyle,
		int	textcolor,
		int	ticscolor,
		int	seg
	)			[static]

Definition at line 2000 of file Axes.c.

References AXES::auto_ticks, sciSubWindow::axes, C2F, Cscale, dr(), DrawXSubTics(), DrawXTics(), DrawYSubTics(), DrawYTics(), findFormat(), FindXYMinMaxAccordingTL(), L, sciSubWindow::logflags, PD0, PI0, pSUBWIN_FEATURE, sciprint(), TRUE, updateXaxesTics(), updateYaxesTics(), and wcscalelist::WIRect1.

Referenced by axesplot().

{
  int switchXY = -1;
  
  char c_format[5];
  integer xx=0,yy=0;
  integer barlength;
  integer fontid[2],fontsize_kp, narg,verbose=0,logrect[4],smallersize=0,color_kp; 
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  double xminval, yminval, xmaxval, ymaxval;
  
  char logflag ;
  /* int lastxindex, lastyindex; */
  BOOL auto_ticks;


  if(pos=='u' || pos=='d'){
    switchXY = 0;
    logflag = ppsubwin->logflags[0];
    auto_ticks = ppsubwin->axes.auto_ticks[0];
  }
  else if(pos=='l' || pos=='r'){
    switchXY = 1;
    logflag = ppsubwin->logflags[1];
    auto_ticks = ppsubwin->axes.auto_ticks[1];
  }


  fontid[0]= fontstyle;
  
  C2F(dr)("xget","font",&verbose,fontid,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  fontsize_kp = fontid[1] ;
  if (fontsize == -1 )
    { fontid[0]= 0; fontid[1]= 1;  fontsize_kp = fontid[1] ;
    fontid[0]= fontstyle;
    C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);}
  
  if ( fontsize != -1 ) 
    {
      fontid[1] = fontsize ;
      fontid[0]= fontstyle;
      C2F(dr)("xset","font",fontid,fontid+1,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
  if ( textcolor != -1 || ticscolor != -1 ) 
    {
      C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
  
  if (logflag == 'l' && auto_ticks == TRUE)
    {
      C2F(dr)("xstringl","10",&xx,&yy,logrect,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);       
      smallersize=fontid[1]-2;
      C2F(dr)("xset","font",fontid,&smallersize,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
  


  FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval);


  switch (switchXY)
  {
  case 0: /* x horizontal axis */
    {
      char formatY[5] ;
      barlength =  (integer) (Cscale.WIRect1[3]/50.0);
      
      /* remove concealing tics labels */
      
      updateXaxesTics( psubwin, pos, xy, fontid, smallersize ) ;
      
      /* the format may have changed */
      findFormat( psubwin, c_format, formatY ) ;

      /* le "loop on the ticks" */
      DrawXTics(pos, psubwin, xy, c_format, fontid, textcolor, ticscolor, color_kp, logrect, smallersize);
      
      /* subtics display*/
      DrawXSubTics(pos, psubwin, xy, ticscolor, color_kp);
    }
    break;
  case 1: /* y vertical axis */
    {
      char formatX[5] ;
      
      /* int ticsDir[2] = {1,0} ; */
      barlength =  (integer) (Cscale.WIRect1[2]/75.0);

      /* remove concealing tics labels */
      updateYaxesTics( psubwin, pos, xy, fontid, smallersize ) ;

       /* the format may have changed */
      findFormat( psubwin, formatX, c_format ) ;

      /* le "loop on the ticks" */
      DrawYTics(pos, psubwin, xy, c_format, fontid, textcolor, ticscolor, color_kp, logrect, smallersize);
      
      /* subtics display*/
      DrawYSubTics(pos, psubwin, xy, ticscolor, color_kp);
    }
    
    break;
  default:
    sciprint("Axes.c : SciAxisNew : Impossible case");
    return -1;
  }
  
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int SciDrawLines	(	char	pos,
		sciPointObj *	psubwin,
		double	xy,
		int	textcolor,
		int	ticscolor
	)

Definition at line 1125 of file Axes.c.

References C2F, dr(), FindXYMinMaxAccordingTL(), L, PD0, PI0, pSUBWIN_FEATURE, TRUE, XDrawAxisLine(), and YDrawAxisLine().

Referenced by axesplot().

{
  double xminval, yminval, xmaxval, ymaxval;
  int verbose = 0, narg, color_kp;

  if ( textcolor != -1 || ticscolor != -1 ) 
    {
      C2F(dr)("xget","pattern",&verbose,&color_kp,&narg,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
  
  FindXYMinMaxAccordingTL(psubwin,&xminval,&yminval,&xmaxval,&ymaxval);

  if(pos=='u' || pos=='d'){ /* X */
    if( pSUBWIN_FEATURE (psubwin)->axes.axes_visible[0] == TRUE )
      XDrawAxisLine(xminval,xmaxval,xy,ticscolor,color_kp);
  } else if(pos=='l' || pos=='r'){ /* Y */
    if(pSUBWIN_FEATURE (psubwin)->axes.axes_visible[1] == TRUE)
      YDrawAxisLine(yminval,ymaxval,xy,ticscolor,color_kp);
  }
  
  
  
  
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void triedre	(	sciPointObj *	pobj,
		double *	xbox,
		double *	ybox,
		double *	zbox,
		integer *	InsideU,
		integer *	InsideD
	)

Definition at line 2940 of file Axes.c.

References BT_ON, C2F, dr(), DrawAxis(), L, PD0, PI0, pSUBWIN_FEATURE, SCI_SUBWIN, sciGetEntityType(), sciGetForeground(), sciGetLineStyle(), sciGetLineWidth(), and x.

Referenced by drawSubWinEntity().

{
  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*/

}

Here is the call graph for this function:

Here is the caller graph for this function:

void updateScaleIfRequired

(

sciPointObj *

pSubWin

)

update the scale factors only if the SubWindow won't be automatically redrawn. Should be called before dr("xstringl") for example.

Definition at line 2800 of file Axes.c.

References sciGetIsAutoDrawable(), and updateSubWinScale().

Referenced by callXstringL(), getTextBoundingBox(), Objstring(), and sci_xstringl().

{
  if ( !sciGetIsAutoDrawable( pSubWin ) )
  {
    updateSubWinScale( pSubWin ) ;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void updateSubWinScale

(

sciPointObj *

pSubWin

)

Update the current scale factors from a modified SubWindow. This is sometimes required when the redraw is disable.

Definition at line 2776 of file Axes.c.

References NULL, pSUBWIN_FEATURE, sci_update_frame_bounds_2d(), set_scale(), and updateScale3d().

Referenced by updateScaleIfRequired().

{
  double xBox[8] ;
  double yBox[8] ;
  double zBox[8] ;
  double dBox[6] ;


  set_scale ("tttftt", pSUBWIN_FEATURE(pSubWin)->WRect,
    pSUBWIN_FEATURE(pSubWin)->FRect,
    NULL, pSUBWIN_FEATURE(pSubWin)->logflags, 
    pSUBWIN_FEATURE(pSubWin)->ARect); 

  /* Scales are not be updated with an automatic drawing */
  if ( pSUBWIN_FEATURE(pSubWin)->is3d )
  {
    updateScale3d( pSubWin, dBox, xBox, yBox, zBox ) ;
  }
  else
  {
    sci_update_frame_bounds_2d( pSubWin ) ;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void updateXaxesTics	(	sciPointObj *	psubwin,
		char	side,
		double	y,
		int	fontId[2],
		int	smallersize
	)

Definition at line 2599 of file Axes.c.

References sciSubWindow::axes, checkXAxes2dTics(), findFormat(), GradLog(), sciSubWindow::logflags, AXES::nxgrads, pSUBWIN_FEATURE, sciGetDisplayedBounds(), TheTicks(), TRUE, and AXES::xgrads.

Referenced by SciAxisNew().

{
  sciSubWindow * ppSubWin = pSUBWIN_FEATURE( psubwin ) ;
  char labelXFormat[5] ;
  char labelYFormat[5] ;
  findFormat( psubwin, labelXFormat, labelYFormat ) ;
  
  /* check if the ticks are concealing or not */
  if ( !checkXAxes2dTics( psubwin, side, y, labelXFormat, fontId, smallersize ) ) 
  {
    double xMin ;
    double xMax ;
    double yMin ;
    double yMax ;
    double zMin ;
    double zMax ;
    int    ticksStatus = 0 ;
    
    sciGetDisplayedBounds( psubwin, &xMin, &xMax, &yMin, &yMax, &zMin, &zMax ) ;
    
    ppSubWin->axes.nxgrads = ( ppSubWin->axes.nxgrads + 1 ) / 2 ;
    
    /* recompute the ticks */
    if ( ppSubWin->logflags[0] == 'n' )
    {
      TheTicks( &xMin, &xMax, ppSubWin->axes.xgrads, &ppSubWin->axes.nxgrads, TRUE ) ;
    }
    else
    {
      GradLog( xMin, xMax, ppSubWin->axes.xgrads, &ppSubWin->axes.nxgrads, TRUE ) ;
    }

    findFormat( psubwin, labelXFormat, labelYFormat ) ;

    while( ticksStatus == 0 && !checkXAxes2dTics( psubwin, side, y, labelXFormat, fontId, smallersize ) )
    {
      ppSubWin->axes.nxgrads = ( ppSubWin->axes.nxgrads + 1 ) / 2 ;
      if (  ppSubWin->logflags[0] == 'n' )
      {
        ticksStatus = TheTicks( &xMin, &xMax, ppSubWin->axes.xgrads, &ppSubWin->axes.nxgrads, TRUE ) ;
      }
      else
      {
        GradLog( xMin, xMax, ppSubWin->axes.xgrads, &ppSubWin->axes.nxgrads, TRUE ) ;
      }

      findFormat( psubwin, labelXFormat, labelYFormat ) ;

    }

  }
  /* else everything ok */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void updateYaxesTics	(	sciPointObj *	psubwin,
		char	side,
		double	x,
		int	fontId[2],
		int	smallersize
	)

Definition at line 2661 of file Axes.c.

References sciSubWindow::axes, checkYAxes2dTics(), findFormat(), GradLog(), sciSubWindow::logflags, AXES::nygrads, pSUBWIN_FEATURE, sciGetDisplayedBounds(), TheTicks(), TRUE, and AXES::ygrads.

Referenced by SciAxisNew().

{
  sciSubWindow * ppSubWin = pSUBWIN_FEATURE( psubwin ) ;
  char labelXFormat[5] ;
  char labelYFormat[5] ;
  findFormat( psubwin, labelXFormat, labelYFormat ) ;
  
  /* check if the ticks are concealing or not */
  if ( !checkYAxes2dTics( psubwin, side, x, labelYFormat, fontId, smallersize ) ) 
  {
    double xMin ;
    double xMax ;
    double yMin ;
    double yMax ;
    double zMin ;
    double zMax ;
    int    ticksStatus = 0 ;
    
    sciGetDisplayedBounds( psubwin, &xMin, &xMax, &yMin, &yMax, &zMin, &zMax ) ;
    
    ppSubWin->axes.nygrads = ( ppSubWin->axes.nygrads + 1 ) / 2 ;
    
    /* recompute the ticks */
    if ( ppSubWin->logflags[1] == 'n' )
    {
      TheTicks( &yMin, &yMax, ppSubWin->axes.ygrads, &ppSubWin->axes.nygrads, TRUE ) ;
    }
    else
    {
      GradLog( yMin, yMax, ppSubWin->axes.ygrads, &ppSubWin->axes.nygrads, TRUE ) ;
    }

    findFormat( psubwin, labelXFormat, labelYFormat ) ;

    while( ticksStatus == 0 && !checkYAxes2dTics( psubwin, side, x, labelYFormat, fontId, smallersize ) )
    {
      ppSubWin->axes.nygrads = ( ppSubWin->axes.nygrads + 1 ) / 2 ;
      if (  ppSubWin->logflags[1] == 'n' )
      {
        ticksStatus = TheTicks( &yMin, &yMax, ppSubWin->axes.ygrads, &ppSubWin->axes.nygrads, TRUE ) ;
      }
      else
      {
        GradLog( yMin, yMax, ppSubWin->axes.ygrads, &ppSubWin->axes.nygrads, TRUE ) ;
      }

      findFormat( psubwin, labelXFormat, labelYFormat ) ;

    }

  }
  /* else everything ok */
}

Here is the call graph for this function:

Here is the caller graph for this function:

static double x_convert	(	char	xy_type,
		double *	x,
		int	i
	)			[static]

Definition at line 810 of file Axes.c.

Referenced by Sci_Axis().

{
  switch ( xy_type ) { 
  case 'v' :  return x[i];
  case 'r' :  return x[0]+i*(x[1]-x[0])/x[2];
  case 'i' :  return exp10(x[2])*(x[0] + i*(x[1]-x[0])/x[3]);
  }
  return 0.0;
}

Here is the caller graph for this function:

static int XDrawAxisLine	(	double	xminval,
		double	xmaxval,
		double	xy,
		int	ticscolor,
		int	color_kp
	)			[static]

Definition at line 1951 of file Axes.c.

References C2F, dr(), iflag, L, PD0, PI0, XScale(), and YScale().

Referenced by SciDrawLines().

{
  int vx[2], vy[2];
  int ns=2, iflag=0;
  
  vx[0] =  XScale(xminval); /* C EST LA que se calcule les positions initiales et finales (en x et y) de la barre support de l'axe des abscisses */
  vx[1] =  XScale(xmaxval);
  vy[0]= vy[1] = YScale(xy);
  
  if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
  if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);


  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void XGradPosition	(	sciPointObj *	psubwin,
		int	yy,
		int	rect3
	)			[static]

Definition at line 2130 of file Axes.c.

References FALSE, sciSubWindow::firsttime_x, pSUBWIN_FEATURE, sciSubWindow::XGradMostOnBottom, and sciSubWindow::XGradMostOnTop.

Referenced by checkXAxes2dTics(), and DrawXTics().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  
  if( ppsubwin->firsttime_x )
  {
    ppsubwin->XGradMostOnTop = yy - rect3 ;
    ppsubwin->XGradMostOnBottom = yy ;
    ppsubwin->firsttime_x = FALSE;
  }
  else
  {
    if(yy > ppsubwin->XGradMostOnBottom)
    {
      ppsubwin->XGradMostOnBottom  = yy ;
    }
    if( yy - rect3 < ppsubwin->XGradMostOnTop)
    {
      ppsubwin->XGradMostOnTop = yy - rect3 ;
    }
  }
}

Here is the caller graph for this function:

static double y_convert	(	char	xy_type,
		double *	y,
		int	i
	)			[static]

Definition at line 820 of file Axes.c.

Referenced by Sci_Axis().

{
  switch ( xy_type ) { 
  case 'v' :  return y[i]; 
  case 'r' :  return y[0]+i*(y[1]-y[0])/y[2];
  case 'i' :  return exp10(y[2])*(y[0] + i*(y[1]-y[0])/y[3]); 
  }
  return 0.0; 
}

Here is the caller graph for this function:

static int YDrawAxisLine	(	double	yminval,
		double	ymaxval,
		double	xy,
		int	ticscolor,
		int	color_kp
	)			[static]

Definition at line 1968 of file Axes.c.

References C2F, dr(), iflag, L, PD0, PI0, XScale(), and YScale().

Referenced by SciDrawLines().

{
  int vx[2], vy[2];
  int ns=2, iflag=0;

  vy[0] =  YScale(yminval); /* C EST LA que se calcule les positions initiales et finales (en x et y) de la barre support de l'axe des abscisses */
  vy[1] =  YScale(ymaxval);
  vx[0]= vx[1] = XScale(xy);
  
  if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&ticscolor,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
  C2F(dr)("xsegs","v", vx, vy, &ns,&ticscolor,&iflag,PI0,PD0,PD0,PD0,PD0,0L,0L);
  if ( ticscolor != -1 ) C2F(dr)("xset","pattern",&color_kp,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);


  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void YGradPosition	(	sciPointObj *	psubwin,
		int	xx,
		int	rect2
	)			[static]

Definition at line 2113 of file Axes.c.

References FALSE, sciSubWindow::firsttime_y, pSUBWIN_FEATURE, TRUE, sciSubWindow::YGradMostOnLeft, and sciSubWindow::YGradMostOnRight.

Referenced by checkYAxes2dTics(), and DrawYTics().

{
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE(psubwin);
  
  if(ppsubwin->firsttime_y == TRUE)
    {
      ppsubwin->YGradMostOnLeft = xx;
      ppsubwin->YGradMostOnRight = xx + rect2;
      ppsubwin->firsttime_y = FALSE;
    }
  else
    {
      if(xx < ppsubwin->YGradMostOnLeft)  ppsubwin->YGradMostOnLeft  = xx;
      if(xx + rect2 > ppsubwin->YGradMostOnRight) ppsubwin->YGradMostOnRight = xx + rect2;
    }
}

Here is the caller graph for this function:

---