window_manager.c

LastWave

/*
 * Get the screen size
 */
void WScreenRect(int *x, int *y, int *w, int *h)
{
  if (GraphicMode)  XXScreenRect(x, y, w, h);
  else {
    *x = *y = 0;
    *w = *h = 10000;
  }
}

/*
 * Get the default foreground and background colors
 */

void WBgColor(unsigned short *r,unsigned short *g,unsigned short *b)
{
  if (GraphicMode)  XXBgColor(r,g,b);
  else *r = *g = *b = 65535;
}

void WFgColor(unsigned short *r,unsigned short *g,unsigned short *b)
{
  if (GraphicMode)  XXFgColor(r,g,b);
  else *r = *g = *b = 0;
}



 
 
/*********************************************************************
 *
 * Functions to draw on windows using gobject or window coordinates
 *
 *********************************************************************/
 
/* Draw a line */
void WDrawLine(GOBJECT o,LWFLOAT x,LWFLOAT y,LWFLOAT x1,LWFLOAT y1)
{
  int wx,wy,wx1,wy1,i;
  WINDOW win;

  if (flagInvisible) return;
  win = GetWin(o);
  if (win->flagHide) return;
  if (win->frame == (FRAME) NULL && !PSMode) Errorf("Weird error");
 
  Local2Global(o,x,y,&wx,&wy);
  Local2Global(o,x1,y1,&wx1,&wy1);
  
  /* Intersecting the window boundary ? */
  if (wx < 0 || wx1 < 0 || wx > win->w || wx1 > win->w) {
    if (wx < 0 && wx1 < 0) return;
    if (wx > win->w && wx1 > win->w) return;
    if (wx > wx1) {
      i = wx; wx = wx1; wx1 = i;
      i = wy; wy = wy1; wy1 = i;
    }
    if (wx < 0) {
      wy = -wx*(wy1-wy)/(wx1-wx)+wy;
      wx = 0; 
    }
    else if (wx1 > win->w) {
      wy1 = (win->w-wx)*(wy1-wy)/(wx1-wx)+wy;
      wx1 = win->w; 
    }
  }
  if (wy < 0 || wy1 < 0 || wy > win->h || wy1 > win->h) {
    if (wy < 0 && wy1 < 0) return;
    if (wy > win->h && wy1 > win->h) return;
    if (wy > wy1) {
      i = wx; wx = wx1; wx1 = i;
      i = wy; wy = wy1; wy1 = i;
    }
    if (wy < 0) {
      wx = -wy*(wx1-wx)/(wy1-wy)+wx;
      wy = 0; 
    }
    else if (wy1 > win->h) {
      wx1 = (win->h-wy)*(wx1-wx)/(wy1-wy)+wx;
      wy1 = win->h; 
    }
  }
        
  if (PSMode) PSDrawLine(wx,wy,wx1,wy1); 
  else if (GraphicMode) XXDrawLine(win->frame,wx,wy,wx1,wy1);
}

/* Draw a point */
void WDrawPoint(GOBJECT o,LWFLOAT x,LWFLOAT y)
{
  int wx,wy;
  WINDOW win;
  
  if (flagInvisible) return;
  win = GetWin(o);
  if (win->flagHide) return;
  if (win->frame == (FRAME) NULL && !PSMode) Errorf("Weird error");

  Local2Global(o,x,y,&wx,&wy);

  if (PSMode) PSDrawPoint(wx,wy); 
  else if (GraphicMode) XXDrawPoint(win->frame,wx,wy);
}


/*
 *
 * Drawing Shapes defined by a rectangle
 *
 */

enum {  
  ShapeRect = 1,
  ShapeEllipse,
  ShapeCross
};


static void DrawShape(char shape, GOBJECT o, LWFLOAT x,LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel, RectType rectType,char flagFilled)
{
  int wx,wy,ww,wh;
  WINDOW win;
  
  if (flagInvisible) return;

  win = GetWin(o);
  if (win->flagHide) return;
  if (win->frame == (FRAME) NULL && !PSMode) Errorf("Weird error");
  
  if (!flagSizeIsInPixel) Local2GlobalRect(o,x,y,dx,dy,rectType,&wx,&wy,&ww,&wh);
  else {
    Local2Global(o,x,y,&wx,&wy);
    ww = (int) dx;
    wh = (int) dy;
    GRect2Rect(&wx,&wy,&ww,&wh,rectType);
  }
  
  if (shape == ShapeRect) {
    if (!flagFilled) {  
      if (PSMode) PSDrawRect(wx,wy,ww,wh);
      else if (GraphicMode) XXDrawRect(win->frame,wx,wy,ww,wh);
    }
    else {
      if (PSMode) PSFillRect(wx,wy,ww,wh);
      else if (GraphicMode) XXFillRect(win->frame,wx,wy,ww,wh);
    }
  }
  else if (shape == ShapeEllipse) {
    if (!flagFilled) {  
      if (PSMode) PSDrawEllipse(wx,wy,ww,wh);
      else if (GraphicMode) XXDrawEllipse(win->frame,wx,wy,ww,wh);
    }
    else {
      if (PSMode) PSFillEllipse(wx,wy,ww,wh);
      else if (GraphicMode) XXFillEllipse(win->frame,wx,wy,ww,wh);
    }
  }
}  

void WClearRect(GOBJECT o,unsigned long color, LWFLOAT x,LWFLOAT y,LWFLOAT dx,LWFLOAT dy,char flagSizeIsInPixel,RectType rectType)
{
  WINDOW win;
    
  win = GetWin(o);
  if (win->flagHide) return;
  if (win->frame == (FRAME) NULL && !PSMode) Errorf("Weird error");
  WSetColor(win,color); 

  DrawShape(ShapeRect,o,x,y,dx,dy,flagSizeIsInPixel,rectType,YES);
} 

void WDrawRect(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel,RectType rectType)
{
  DrawShape(ShapeRect,o,x,y,dx,dy,flagSizeIsInPixel,rectType,NO);
} 

void WFillRect(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel, RectType rectType)
{
  DrawShape(ShapeRect,o,x,y,dx,dy,flagSizeIsInPixel,rectType,YES);
} 

void WDrawEllipse(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel, RectType rectType)
{
  DrawShape(ShapeEllipse,o,x,y,dx,dy,flagSizeIsInPixel,rectType,NO);
} 

void WFillEllipse(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel, RectType rectType)
{
  DrawShape(ShapeEllipse,o,x,y,dx,dy,flagSizeIsInPixel,rectType,YES);
} 


/*
 *
 * Drawing Shapes defined by a centered rectangle
 *
 */
  
static void DrawCenteredShape(char shape, GOBJECT o, LWFLOAT x,LWFLOAT y, LWFLOAT r1, LWFLOAT r2, char flagSizeIsInPixel, char flagFilled)
{
  int wx,wy,wx1,wy1,dx,dy;
  WINDOW win;

  if (flagInvisible) return;
  
  if (shape == ShapeCross && PSMode) {
    Local2Global(o,x,y,&wx,&wy);
    PSDrawLine((int) (wx-r1),wy,(int) (wx+r1),wy);
    PSDrawLine(wx,(int) (wy-r2),wx,(int) (wy+r2));
    return;
  }

  if (flagSizeIsInPixel) {
    Local2Global(o,x,y,&wx,&wy);
    wx -= (int) r1;
    wy -= (int) r2;
    dx = (int) (2*r1+1);
    dy = (int) (2*r2+1);
   }
   else {
    Local2Global(o,x-r1,y-r2,&wx,&wy);
    Local2Global(o,x+r1,y+r2,&wx1,&wy1);
    if (wx1 >= wx) wx1++;
    else wx++;
    if (wy1 >= wy) wy1++;
    else wy++;   
    dx = wx1-wx;
    dy = wy1-wy;
    if (dx < 0) {wx += dx-1;dx=-dx;}
    if (dy < 0) {wy += dy-1;dy=-dy;}
  } 
  win = GetWin(o);
  if (win->flagHide) return;

  if (shape == ShapeRect) {
    if (!flagFilled) {  
      if (PSMode) PSDrawRect(wx,wy,dx,dy);
      else if (GraphicMode) XXDrawRect(win->frame,wx,wy,dx,dy);
    }
    else {
      if (PSMode) PSFillRect(wx,wy,dx,dy);
      else if (GraphicMode) XXFillRect(win->frame,wx,wy,dx,dy);
    }
  }
  else if (shape == ShapeEllipse) {
    if (!flagFilled) {  
      if (PSMode) PSDrawEllipse(wx,wy,dx,dy);
      else if (GraphicMode) XXDrawEllipse(win->frame,wx,wy,dx,dy);
    }
    else {
      if (PSMode) PSFillEllipse(wx,wy,dx,dy);
      else if (GraphicMode) XXFillEllipse(win->frame,wx,wy,dx,dy);
    }
  }
  else if (shape == ShapeCross) {
    if (GraphicMode) {
      XXDrawLine(win->frame,(int) (wx+r1),wy,(int) (wx+r1),wy+dy);
      XXDrawLine(win->frame,wx,(int) (wy+r2),wx+dx,(int) (wy+r2));
    }      
  }
}  

void WDrawCenteredRect(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel)
{
  DrawCenteredShape(ShapeRect,o,x,y,dx,dy,flagSizeIsInPixel,NO); /* ?? ps ??*/
} 

void WFillCenteredRect(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel)
{
  DrawCenteredShape(ShapeRect,o,x,y,dx,dy,flagSizeIsInPixel,YES);
} 

void WDrawCenteredEllipse(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel)
{
  DrawCenteredShape(ShapeEllipse,o,x,y,dx,dy,flagSizeIsInPixel,NO); /* ?? ps ??*/
} 

void WDrawCenteredCross(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, char flagSizeIsInPixel)
{
  DrawCenteredShape(ShapeCross,o,x,y,dx,dx,flagSizeIsInPixel,NO); /* ?? ps ??*/
} 

void WFillCenteredEllipse(GOBJECT o,LWFLOAT x, LWFLOAT y, LWFLOAT dx, LWFLOAT dy, char flagSizeIsInPixel)
{
  DrawCenteredShape(ShapeEllipse,o,x,y,dx,dy,flagSizeIsInPixel, YES);
} 



/******************************************************************
 *
 *  Drawing axis 
 *
 ******************************************************************/

/*
 * The following is derived from the quickdraw source ( with major modif.)
 */


#define ALMOST1		.9999999
#define ALMOST1_DIV_5		.1999999
# define PXTICK 4.0 

static double Round[] = { 1., 2., 2.5, 5., 10., 20. };

/* The long ticks of the axis */
static double theXLongTicks[20], theYLongTicks[20];
static int nXLongTicks, nYLongTicks;

/* The short ticks of the axis */
static double theXShortTicks[100], theYShortTicks[100];
static int nXShortTicks, nYShortTicks;


static double g_stsize(double vmin, double vmax,int * n12,double * xvmin,double * xvmax,double * rmin , int *nn0)
{
  double pstep, log10, rstep, order, power, smin, use1, vdif;
  int i, rmin_old;
	
  vdif = vmax - vmin;
  pstep = fabs(vmax - vmin) / 6;
  log10 = log(10.0);
  order = log(pstep)/log10;
	
  if(order < 0) order = order - ALMOST1;
	
  order = (int)order;
  power = pow(10.0, order);
	
  for(i = 0; i < 6; i++) {
    rstep = Round[i]*power;
    if(rstep>=pstep)
    break;
  }
	
  smin = vmin/rstep;
  if(smin < 0) smin = smin - ALMOST1_DIV_5;
  if(vmax < vmin) smin += ALMOST1_DIV_5;	
  *rmin = (int)(5 * smin) / 5. ;
  rmin_old = (int)(smin) ;
  *nn0 = (int)((*rmin - rmin_old) * 5) ;
  if(*nn0 <= 0) *nn0 = - *nn0 ;
  else *nn0 = 5 - *nn0 ;
  *rmin *= rstep ;
  use1 = fabs(rstep);
	
  rstep = (vdif > 0) ? use1 : -use1;
  *xvmin = vmin - vdif * 1.e-5;
  *xvmax = vmax + vdif * 1.e-5;
	
  *n12 = (6 + 1) * (5 + 1);
	
  return (rstep / 5.);
}


static void ComputeTicks(LWFLOAT xMin, LWFLOAT xMax, LWFLOAT yMin, LWFLOAT yMax)
{
  double xvmin, xvmax;
  double value, rstep2, rmin;
  int j, n12, nn, nn0;

  /* The x-axis ticks */
  rstep2 = g_stsize(yMin, yMax, &n12, &xvmin, &xvmax, &rmin, &nn0);
	
  nYLongTicks = -1;
  nYShortTicks = -1;
	
  for(value = rmin, nn = nn0, j = 0; j < n12; j++) {
    if(((value-xvmax)*(value-xvmin)) <= 0) {
      if(fabs(value) < 1.e-3*MAX(fabs(xvmax),fabs(xvmin))) value = 0;

      /* Long tick */
      if(nn == 0) {	
        nYLongTicks++;
        theYLongTicks[nYLongTicks] = value;
      }
      
      /* Short tick */
      nYShortTicks++;
	  theYShortTicks[nYShortTicks] = value;  
    }
	  
	if(nn == 0) nn = 5;
    nn--;	  
    value = rmin + (j + 1) *rstep2; 
  }


  /* The y-axis ticks */  		
  rstep2 = g_stsize(xMin, xMax, &n12, &xvmin, &xvmax, &rmin, &nn0);

  nXLongTicks = -1;
  nXShortTicks = -1;  	
	
  for(value = rmin, nn = nn0, j = 0; j < n12; j++) {
    if((value-xvmax)*(value-xvmin) <= 0) {
      if(fabs(value) < 1.e-3*MAX(fabs(xvmax),fabs(xvmin))) value = 0;
      
      /* Long tick */
	  if(nn == 0) {	
        nXLongTicks++;
        theXLongTicks[nXLongTicks] = value;
      }

      /* Short tick */	    
      nXShortTicks++;
	  theXShortTicks[nXShortTicks] = value;  	    
    }
	  
	if(nn == 0) nn = 5;
    nn--;
    value = rmin+(j+1)*rstep2;
  }	
}



static void DrawAxis_(WINDOW win,int x, int y, int w, int h, LWFLOAT xMin, LWFLOAT xMax, LWFLOAT yMin, LWFLOAT yMax, 
                      char *xText,char * yText,char * titleText,int pixelMargin, char flagTicksIn, char flagFrame,char flagReverse)
{
    int xAxis,yAxis,xAxis1,yAxis1,yLongTick,yLongTick1,yShortTick,yShortTick1,xLongTick,xLongTick1,xShortTick,xShortTick1,xStrTick,yStrTick,x0,y0;
	int i;
	char tempStr[80];
	int hstrMode,vstrMode;
	
	
    /*
	 * Draw in the x-axis
	 */

    /* Draw the axis line */
    if (flagReverse & YFlagReverse) {
      yAxis = y+h-1+pixelMargin;
      yAxis1 = y-pixelMargin;
    }
    else {
      yAxis = y-pixelMargin;
      yAxis1 = y+h-1+pixelMargin;
    }
	WDrawLine((GOBJECT) win,x-pixelMargin, yAxis, x-1+w+pixelMargin, yAxis);
	if (flagFrame) 	WDrawLine((GOBJECT) win,x-pixelMargin, yAxis1, x-1+w+pixelMargin, yAxis1);

	
	/* Draw the long ticks and label them */
	if (flagReverse & YFlagReverse) {
	  vstrMode = VPositionUpStr;
	  if (!flagTicksIn) {
	    yLongTick = (int) (yAxis+2*PXTICK);
	    yLongTick1 =(int)  (yAxis1-2*PXTICK);
	    yStrTick = (int) (yLongTick + 2);
	    yShortTick = (int) (yAxis+PXTICK);
	    yShortTick1 = (int) (yAxis1-PXTICK);
	  }
	  else {
	    yLongTick = (int) (yAxis-2*PXTICK);
	    yLongTick1 = (int) (yAxis1+2*PXTICK);
	    yStrTick = (int) (yAxis + 2);
	    yShortTick = (int) (yAxis-PXTICK);