window_manager.c

LastWave

      vMode = VPositionBaseStr;
      argv++;
    }
    else {
      argv = ParseArgv(argv,tWORD,&vModeStr,tFLOAT,&y,-1);    
      if (!strcmp(vModeStr,"up")) vMode = VPositionUpStr;
      else if (!strcmp(vModeStr,"down")) vMode = VPositionDownStr;
      else if (!strcmp(vModeStr,"base")) vMode = VPositionBaseStr;
      else if (!strcmp(vModeStr,"middle")) vMode = VPositionMiddleStr;
      else if (!strcmp(vModeStr,"middleUp")) vMode = VPositionMiddleUpStr;
      else Errorf("Bad vertical string position mode '%s'",vModeStr);
    }
    
    argv = ParseArgv(argv,tFLOAT_,0.,&angle,-1);    

    flag = DoDrawOptions(w,o,argv,&rectType,&clipWin,&clipX,&clipY,&clipW,&clipH);
    WDrawString(o,str,hMode,x,vMode,y,angle);    
    DoDrawOptions(w,o,NULL,&rectType,&clipWin,&clipX,&clipY,&clipW,&clipH);
    oldObj = NULL;
    return;
  }
  
  /* axis */
  flagReverse = YFlagReverse;
  if (!strcmp(action,"axis")) {
    argv = ParseArgv(argv,tFLOAT,&x,tFLOAT,&y,tFLOAT,&dx,tFLOAT,&dy,tFLOAT,&xMin,tFLOAT, &xMax,tFLOAT, &yMin,tFLOAT, &yMax,-1);
    xlabel = ylabel = title = NULL;
    pixelMargin = 0;
    flagTicksIn = flagFrame = NO;
    while (*argv != NULL) {

/*      if (!strcmp(*argv,"-title")) {
        argv++;
        argv = ParseArgv(argv,tSTR,&title,-1);
        continue;
      }
      if (!strcmp(*argv,"-xlabel")) {
        argv++;
        argv = ParseArgv(argv,tSTR,&xlabel,-1);
        continue;
      }

      if (!strcmp(*argv,"-ylabel")) {
        argv++;
        argv = ParseArgv(argv,tSTR,&ylabel,-1);
        continue;
      }
*/
      if (!strcmp(*argv,"-margin")) {
        argv++;
        argv = ParseArgv(argv,tINT,&pixelMargin,-1);
        continue;
      }

      if (!strcmp(*argv,"-reverse")) {
        argv++;
        argv = ParseArgv(argv,tSTR,&str,-1);
        flagReverse = 0;
        if (!strcmp(str,"xy")) flagReverse = YFlagReverse + XFlagReverse;
        else if (!strcmp(str,"y")) flagReverse = YFlagReverse;
        else if (!strcmp(str,"x")) flagReverse = XFlagReverse;
        else if (!strcmp(str,"none")) flagReverse = 0;
        else Errorf("Bad value '%s' for option '-reverse'",str);
        continue;
      }

      if (!strcmp(*argv,"-in")) {
        argv++;
        flagTicksIn = YES;
        continue;
      }

      if (!strcmp(*argv,"-frame")) {
        argv++;
        flagFrame = YES;
        continue;
      }
      
      break;
    }
    
    DoDrawOptions(w,o,argv,&rectType,&clipWin,&clipX,&clipY,&clipW,&clipH);
    DrawAxis(o,x,y,dx,dy,xMin,xMax,yMin,yMax,xlabel,ylabel,title,pixelMargin,flagTicksIn,flagFrame,flagReverse);
    DoDrawOptions(w,o,NULL,&rectType,&clipWin,&clipX,&clipY,&clipW,&clipH);
    oldObj = NULL;
    return;
  } 
  
  /* Draw a gobject (without adding it) */
  if (!strcmp(action,"gobject")) {  
    argv = ParseArgv(argv,tWORD,&str,-1);
    if (!IsGList(o)) Errorf("The first argument should be a glist not just a gobject");
    list = (GLIST) o;
    class = (GCLASS) GetElemHashTable(theGClasses,str);    
    if (class == NULL) Errorf("'%s' does not correspond to a gclass",str);
    sprintf(name,"_%d_",(int) clock());
    WGetClipRect(&clipWin,&clipX,&clipY,&clipW,&clipH);
    flagClip = NO;
    if (!strcmp(*argv,"-clip")) {
      argv++;
      flagClip = YES;
    }
    o = NewGObject(class,list,name,argv,NO);
    if (clipWin && clipWin == GetWin((GOBJECT) list) && !flagClip) DrawGObject(o,clipX,clipY,clipW,clipH,YES);
    else DrawWholeGObject(o,YES);
    o->flagHide = YES;
    DeleteGObject(o);
    DoDrawOptions(w,(GOBJECT) w,NULL,&rectType,&clipWin,&clipX,&clipY,&clipW,&clipH);
    return;
  } 
  
  Errorf("Unknown action '%s'",action);
}




/********************************
 *
 * Managing Strings
 *
 ********************************/

/*
 *
 * Main routine for Drawing a string or getting its bounding rectangle (if rx != NULL)
 *
 */
 
 /* Pb : si postscript sans graphique */
 
static void _WDrawStringOrGetBoundRect(GOBJECT o,FONT font,char *str, char hPositionMode, LWFLOAT x, char vPositionMode,  LWFLOAT y, double angle, LWFLOAT *rx, LWFLOAT *ry, LWFLOAT *rw, LWFLOAT *rh)
{
  int i0,j0,i,j,ri1,rj1,ri,rj,dj,temp;
  WINDOW win;
  char *str1,*str2;
  int nLines,n;
  int vSize;
  int ascent,descent,interline;
  int strWidth,maxStrWidth;
    
  if (o == NULL && rx == NULL) Errorf("WDrawStringOrGetBoundRect() : Do not know whether you want to getthe BoundRect or draw the string");
  
  /* If not getting the boundrect then we must test whether the object is visible or not */  
  if (rx == NULL) {
    if (flagInvisible) return;
    win = GetWin(o);
    if (win->flagHide) return;
    if (win->frame == (FRAME) NULL && !PSMode) Errorf("Weird error");
    if (str == NULL) return;
    if (!GraphicMode && !PSMode) return;
  }
  
  /* Get local coordinates */
  if (o != NULL) Local2Global(o,x,y,&i0,&j0);
  else {
    i0 = (int) (x+.5); 
    j0 = (int) (y+.5); 
  }
  
  /* Let us first compute the number of lines */
  nLines = 1;
  str1 = str;
  while (1) {
    str2 = strchr(str1,'\n');
    if (str2 == NULL) break;
    str1 = str2+1;
    nLines++;
  }
  
  /* Then we compute the vertical size of the whole block */
  ascent = font->ascent;
  descent = font->descent;
  interline = font->interline;
  vSize = nLines*(ascent+descent+interline) -interline;
  
  /* In case HPositionMiddle1Str or HPositionRight1Str we must compute the maximum string width */
  if (hPositionMode == HPositionMiddle1Str || hPositionMode == HPositionRight1Str) {
    maxStrWidth = -1;
    str1 = str;
    while (1) {
      str2 = strchr(str1,'\n');
      if (str2 != NULL) *str2 = '\0';
      strWidth = XXGetStringWidth(font,str1);
      if ((strWidth > maxStrWidth) && PSMode) PSMaxString(str1);
      maxStrWidth = MAX(maxStrWidth,strWidth);
      if (str2 == NULL) break;
      *str2 = '\n';
      str1 = str2+1;
    }
  }
  
  /* Then we loop on all the lines */
  str1 = str;
  n = 0;
  ri = rj= INT_MAX/2;
  ri1 = rj1 = -INT_MAX/2;
  while (1) {
    n++;
    str2 = strchr(str1,'\n');
    if (str2 != NULL) *str2 = '\0';
    
    if (PSMode && rx == NULL) {
      dj = 0;
      if (vPositionMode == VPositionDownStr) dj = vSize-(ascent+descent);
      else if (vPositionMode == VPositionMiddleStr || vPositionMode == VPositionMiddleUpStr) dj = (vSize-ascent-descent)/2;
      PSDrawString(str1,hPositionMode,i0,vPositionMode,j0-dj+(n-1)*(ascent+descent+interline));
      if (str2 == NULL) break;
      *str2 = '\n';
      str1 = str2+1;
      continue;
    }
        
    /* Let us fix the vertical position */
    switch (vPositionMode) {
    
      case VPositionBaseStr: j = j0+(n-1)*(ascent+descent+interline); break;

      case VPositionUpStr:
        j = j0+ascent+1+(n-1)*(ascent+descent+interline);
        break;

      case VPositionDownStr:
        j = j0-vSize+ascent+(n-1)*(ascent+descent+interline);
        break;

      case VPositionMiddleStr:
        j = j0-vSize/2+ascent+1+(n-1)*(ascent+descent+interline);
        break;

      case VPositionMiddleUpStr:
        j = j0-vSize/2+descent/2+ascent+1+(n-1)*(ascent+descent+interline);
        break;
    }
 
    /* Let us then fix the horizontal position */
    switch (hPositionMode) {
  
      /* Justify left */
      case HPositionLeftStr : 
        i = i0; 
        strWidth = XXGetStringWidth(font,str1);
        break;

      /* Justify right each line separately */
      case HPositionRightNStr : 
        strWidth = XXGetStringWidth(font,str1);
        i = i0-strWidth;
        break;

      /* Justify right all the lines as a block */
      case HPositionRight1Str : 
        strWidth = XXGetStringWidth(font,str1);
        i = i0-maxStrWidth;
        break;

      /* Justify middle each line separately */
      case HPositionMiddleNStr : 
        strWidth = XXGetStringWidth(font,str1);
        i = i0-strWidth/2;
        break;

      /* Justify middle all the lines as a block */
      case HPositionMiddle1Str : 
        i = i0-maxStrWidth/2;
        break;
    }
        
    /* Computing the bounding rect if necessary */
    if (rx != NULL) {
      ri = MIN(i,ri); 
      rj = MIN(rj,j-ascent-1);
      rj1 = MAX(rj1,j+descent);
      if (hPositionMode == HPositionMiddle1Str) ri1 = i0+maxStrWidth/2;
      else if (hPositionMode == HPositionRight1Str) ri1 = i+maxStrWidth;
      else ri1 = MAX(ri1,i+strWidth); 
      if (angle == 90) {
        temp = rj;
        rj = rj-(ri1-ri);
        ri1 = ri + (rj1-temp);
        rj1 = temp;
      }            
    }
    
    /* Draw the string if asked */
    if (rx == NULL) XXDrawString(win->frame,i,j,str1,angle);
  
    if (str2 == NULL) break;
    *str2 = '\n';
    str1 = str2+1;
  }
  
  if (rx != NULL) {
    if (o !=NULL) Global2LocalRect(o,ri,rj,ri1-ri+1,rj1-rj+1,rx,ry,rw,rh,NormalRect);
    else {
      *rx = ri; 
      *ry = rj;
      *rw = ri1-ri+1;
      *rh = rj1-rj+1;
    }
  }
  
}


void WDrawString(GOBJECT o,char *str, char hPositionMode, LWFLOAT x, char vPositionMode, LWFLOAT y, double angle)
{
  _WDrawStringOrGetBoundRect(o,currentFont,str,hPositionMode,x,vPositionMode,y,angle,NULL,NULL,NULL,NULL);
}

void WGetBoundRectString(GOBJECT o,FONT font,char *str, char hPositionMode, LWFLOAT x, char vPositionMode, LWFLOAT y, LWFLOAT angle, LWFLOAT *rx, LWFLOAT *ry, LWFLOAT *rw, LWFLOAT *rh)
{
  if (angle != 0 && angle != 90) Errorf("WGetBoundRectString() : Bad angle %g",angle);
  
  _WDrawStringOrGetBoundRect(o,font, str,hPositionMode,x,vPositionMode,y,angle,rx,ry,rw,rh);
}



/********************************
 *
 * Managing Fonts
 *
 ********************************/

HASHTABLE theFontHashTable;
FONT defaultFont = NULL;


/* 
 * Miscellenaous funtions
 */

/* Get the name of the encoding from 'encoding' */ 
static char *GetFontEncodingNameFromEncoding(unsigned char encoding)
{
  static char str[255];
  
  str[0] ='\0';
  
  switch(encoding) {
    case FontEncodingDefault : return("default");
    case FontEncodingGreek : return("greek");
  }
}


/* Reverse the above function */
static unsigned char GetFontEncodingFromEncodingName(char *str)
{
  unsigned char encoding;
  
  if (!strcmp(str,"default")) encoding = FontEncodingDefault;
  else if (!strcmp(str,"greek")){encoding = FontEncodingGreek;}
  else {
    SetErrorf("GetFontEncodingFromEncodingName() : Bad encoding name '%s'",str);
    return(FontEncodingError);
  }
  
  return(encoding);
}


/* Get the name of the style from 'style' */ 
static char *GetFontStyleNameFromStyle(unsigned char style)
{
  static char str[255];
  
  str[0] ='\0';
  
  if (style & FontBold) strcat(str,"bold");
  if (style & FontItalic) {
    if (*str == '\0') strcat(str,"italic");
    else strcat(str,"Italic");
  }
  if (style == FontPlain) strcat(str,"plain");
  
  return(str);
}

/* Reverse the above function */
static unsigned char GetFontStyleFromStyleName(char *str)
{
  unsigned char style;

  if (!strcmp(str,"plain")) style = FontPlain;
  else if (!strcmp(str,"bold")) style = FontBold;
  else if (!strcmp(str,"italic")) style = FontItalic;
  else if (!strcmp(str,"boldItalic")) style = FontItalic | FontBold;
  else {
    SetErrorf("GetFontStyleFromStyleName() : Bad style name '%s'",str);
    return(FontError);
  }
  
  return(style);
}

/* Get the name of the font given the 'name', 'size' and 'style' and encoding */
char *GetFontFullName(char *name, int size, unsigned char style, unsigned char encoding)
{
  static char str[200];

  sprintf(str,"%s-%d-%s-%s",name,size,GetFontStyleNameFromStyle(style),GetFontEncodingNameFromEncoding(encoding));
  return(str);
}

/* Reverse of the above procedure */
static char GetFontNameSizeStyleEncoding(char *str, char **name, int *size, unsigned char *style,unsigned char *encoding)
{
  static char str0[200],str00[200];
  char *str1,*str2,*str3,*str4,*tempStr;
  char *endStr1,*endStr2,*endStr3,*endStr4;
  char *endp;
  long l;
  
  if (str == NULL) Errorf("GetFontNameSizeStyleEncoding() : Weird error");
    
  /* Looking for the first string */
  str1 = tempStr = str;
  tempStr = str;
  while(*tempStr != '\0' && *tempStr != '-') tempStr++;
  endStr1 = tempStr;
  if (*str1 == *endStr1) {
    SetErrorf("GetFontNameSizeStyleEncoding() : Bad font name '%s'.",str);
    return(NO);
  }
 
  /* Looking for the second string */
  if (*endStr1 == '\0') str2 = endStr2 = NULL;
  else {
    str2 = tempStr = endStr1+1;
    while(*tempStr != '\0' && *tempStr != '-') tempStr++;
    endStr2 = tempStr;
    if (*str2 == *endStr2) {
      SetErrorf("GetFontNameSizeStyleEncoding() : Bad font name '%s'.",str);
      return(NO);
    }
  }

  /* Looking for the third string */
  if (str2 == NULL || *endStr2 == '\0') str3 = endStr3 = NULL;
  else {
    str3 = tempStr = endStr2+1;
    while(*tempStr != '\0' && *tempStr != '-') tempStr++;
    endStr3 = tempStr;
    if (*str3 == *endStr3) {
      SetErrorf("GetFontNameSizeStyleEncoding() : Bad font name '%s'.",str);
      return(NO);
    }
  }

  /* Looking for the fourth string */
  if (str3 == NULL || *endStr3 == '\0') str4 = endStr4 = NULL;
  else {
    str4 = tempStr = endStr3+1;
    while(*tempStr != '\0' && *tempStr != '-') tempStr++;
    endStr4 = tempStr;
    if (*str4 == *endStr4) {
      SetErrorf("GetFontNameSizeStyleEncoding() : Bad font name '%s'.",str);
      return(NO);
    }
    /* If some more strings are left then error */
    if (*endStr4 != '\0') {