t1finfo.c

source code: Covert TXT to PDF

    return(NULL);
  }
  
  strncpy(notice,
	  (char *)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[NOTICE].value.data.nameP),
	  pFontBase->pFontArray[FontID].pType1Data->fontInfoP[NOTICE].value.len);
  notice[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[NOTICE].value.len]=0;
    
  return(notice);
  
}




/* char *T1_GetCharName(): Get the PostScript character name of
   the  character indexed by char1. */
char *T1_GetCharName( int FontID, char char1)
{
  static char cc_name1[256];
  char *c1;
  

  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }

  if (pFontBase->pFontArray[FontID].pFontEnc==NULL){
    /* We have to get the names from the fonts internal encoding */
    c1= (char *)pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].data.arrayP;
    strncpy(cc_name1,
	    (char *)pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].data.arrayP,
	    pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].len);
    cc_name1[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].len]=0;
  }
  else{
    /* Take names from explicitly loaded and assigned encoding */
    c1=pFontBase->pFontArray[FontID].pFontEnc[(unsigned char)char1];
    strcpy(cc_name1,c1);
  }

  /* Return address of charname */
  return(cc_name1);
  
}



/* T1_QueryLigs(): Get the number of ligatures defined in the font FontID for
   the character which is located at position char1 in the current encoding
   vector!
   Function returns the number of defined ligs (including 0) or -1 if an
   error occured.
   */
int T1_QueryLigs( int FontID,  char char1, char **successors,
		  char **ligatures)
{

  FontInfo *afm_ptr;
  CharMetricInfo *m_ptr;
  char *c_name;
  char cc_name[128];
  static char succ[MAX_LIGS];
  int succ_index;
  static char lig[MAX_LIGS];
  int lig_index;
  
  Ligature *ligs;
  int i,j;
  
  /* Check whether font is loaded: */
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(-1);
  }
  
  /* If no AFM info is present, we return an error */
  if (pFontBase->pFontArray[FontID].pAFMData==NULL) {
    T1_errno=T1ERR_NO_AFM_DATA;
    return( -1);
  }

  /* All OK, ... */
  afm_ptr=pFontBase->pFontArray[FontID].pAFMData;
  m_ptr=afm_ptr->cmi;

  /* Get the name of the character: */
  if (pFontBase->pFontArray[FontID].pFontEnc==NULL){
    /* We have to get the name from the fonts internal encoding */
    c_name=(char *)pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].data.arrayP;
    strncpy(cc_name,
	    (char *)pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].data.arrayP,
	    pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].len);
    cc_name[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[(unsigned char)char1].len]=0;
  }
  else{
    /* Take name from explicitly loaded and assigned encoding */
    c_name=pFontBase->pFontArray[FontID].pFontEnc[(unsigned char)char1];
    strcpy(cc_name,c_name);
  }

  for (i=0; i<afm_ptr->numOfChars; i++){
    if (strcmp(m_ptr[i].name,cc_name)==0)
      break;
  }
  

  if (i==afm_ptr->numOfChars) /* we didn't find the characters name */
    return(-1);
  
  ligs=m_ptr[i].ligs;

  j=0;
  if (ligs==NULL)
    return(0);
  
  while (ligs!=NULL) {
    /* Get indices of the two characters: */
    if ((succ_index=T1_GetEncodingIndex( FontID, (char*) ligs->succ))==-1) {
      /* successor is not current encoding */
      ligs=ligs->next;
      continue;
    }
    if ((lig_index=T1_GetEncodingIndex( FontID, (char*) ligs->lig))==-1) {
      /* Specified ligature is not in current encoding */
      ligs=ligs->next;
      continue;
    }
    succ[j]=(char)succ_index;
    lig[j]=(char)lig_index;
    j++;
    ligs=ligs->next;
  }
    
  *successors=succ;
  *ligatures=lig;
  
  return(j);
}

      

/* T1_GetEncodingIndex(): Return the Index of char1 in the current
   encoding vector of font FontID */
int T1_GetEncodingIndex( int FontID, char *char1)
{
  int i;
  int len1;
  int result_index;
  char **extern_enc;
  psobj *objptr;
  
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(-1);
  }

  extern_enc=pFontBase->pFontArray[FontID].pFontEnc;

  len1=strlen( char1);
  
  /* The default return-value if character is not found: */
  result_index=-1;

  if (extern_enc==NULL) {
    objptr=&(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[0]);
    /* We have to search the fonts internal encoding */
    for (i=0;i<256;i++){
      if (len1==objptr[i].len){
	if (strncmp((char *)objptr[i].data.arrayP,
		    char1, objptr[i].len)==0){ 
	  result_index=i; 
	  break; 
	}
      }
    }
    
  }
  else {
    /* Take name from explicitly loaded and assigned encoding */
    for (i=0;i<256;i++){
      if (strcmp(extern_enc[i], char1)==0){
	result_index=i;
	break;
      }
    }
  }

  return(result_index);
}


/* T1_GetEncodingIndices(): Return all indices of char1 in the current
   encoding vector of font FontID. */
int *T1_GetEncodingIndices( int FontID, char *char1)
{
  int i;
  int endmark=0;
  int len1;
  char **extern_enc;
  psobj *objptr;
  /* the following array suffices for the extreme unlikely case of a font
     where one single fillsthe whole encoding vector */
  static int indices[257];

  
  if (CheckForFontID(FontID)!=1) {
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }

  extern_enc=pFontBase->pFontArray[FontID].pFontEnc;

  len1=strlen( char1);
  
  if (extern_enc==NULL) {
    objptr=&(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ENCODING].value.data.arrayP[0]);
    /* We have to search the fonts internal encoding */
    for (i=0;i<256;i++){
      if (len1==objptr[i].len){
	if (strncmp((char *)objptr[i].data.arrayP,
		    char1, objptr[i].len)==0){ 
	  indices[endmark++]=i; 
	}
      }
    }
  }
  else {
    /* Take name from explicitly loaded and assigned encoding */
    for (i=0;i<256;i++){
      if (strcmp(extern_enc[i], char1)==0){
	indices[endmark++]=i; 
      }
    }
  }

  indices[endmark]=-1;
  return((int *)indices);
}


/* int T1_GetStringWidth(): This function returns the width of string
   in .afm-file units. If no .afm-file is loaded for font FontID,
   0 is returned. Note that if one tries to raster strings, afm data
   should always be available. The returned character width is corrected
   using  a possibly applied font extension!
   */
int T1_GetStringWidth( int FontID, char *string,
		       int len,  long spaceoff, int kerning)
{

  int no_chars;      /* Number of chars in string */
  int i;
  int *kern_pairs;
  int *charwidths;
  int spacewidth; 
  int stringwidth;

  unsigned char *ustring;

  ustring=(unsigned char *) string;
  
  /* First, check for a correct ID */
  i=CheckForFontID(FontID);
  if (i!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(0);
  }
  
  /* If no AFM info is present, we return an error */
  if (pFontBase->pFontArray[FontID].pAFMData==NULL) {
    T1_errno=T1ERR_NO_AFM_DATA;
    return( 0);
  }

  /* Get length of string: */
  if (len<0 || ustring == NULL){  /* invalid length or NULL-pointer */
    T1_errno=T1ERR_INVALID_PARAMETER;
    return(0);
  }
  if (len==0) /* should be computed assuming "normal" 0-terminated string */
    no_chars=strlen(string);
  else        /* use value given on command line */
    no_chars=len;

  /* Allocate room for temporary arrays of kerning and width arrays: */
  kern_pairs=(int *)calloc(no_chars -1, sizeof(int));
  if (kern_pairs==NULL){
    T1_errno=T1ERR_ALLOC_MEM;
    return(0);
  }
  charwidths=(int *)calloc(no_chars, sizeof(int));
  if (charwidths==NULL){
    T1_errno=T1ERR_ALLOC_MEM;
    return(0);
  }
  
  /* If kerning is requested, get kerning amounts and fill the array: */
  if (kerning){
    for (i=0; i<no_chars -1; i++){
      kern_pairs[i]=T1_GetKerning( FontID, ustring[i], ustring[i+1]);
    }
  }
  
  /* Compute the correct spacewidth value (in charspace units): */
  spacewidth=T1_GetCharWidth(FontID,pFontBase->pFontArray[FontID].space_position)+spaceoff;
  
  /* Fill the width-array:  */
  for (i=0; i<no_chars; i++){
    if (ustring[i]==pFontBase->pFontArray[FontID].space_position)
      charwidths[i]=(int)spacewidth;
    else
      charwidths[i]=T1_GetCharWidth(FontID,ustring[i]);
  }
  
  /* Accumulate width: */
  stringwidth=0;
  for (i=0; i<no_chars-1; i++){
    stringwidth += kern_pairs[i];
  }
  for (i=0; i<no_chars; i++){
    stringwidth += charwidths[i];
  }
  
  /* free memory: */
  free( charwidths);
  free( kern_pairs);

  /* .. and return result: */
  return( stringwidth);

}

    

/* int T1_GetStringBBox(): This function returns the bounding box of string
   in .afm-file units. If no .afm-file is loaded for font FontID,
   0 is returned. Note that if one tries to raster strings, afm data
   should always be available. The returned character width is corrected
   using  a possibly applied font extension!
   */
BBox T1_GetStringBBox( int FontID, char *string,
		       int len,  long spaceoff, int kerning)
{

  BBox NullBBox= { 0, 0, 0, 0}; /* A bounding box containing all 0's. */
  BBox tmp_BBox= { 0, 0, 0, 0}; 
  BBox ResultBBox= { 0, 0, 0, 0}; /* The resulting BBox */
  int i;
  int no_chars;
  int curr_width=0;
  int spacewidth=0;
  
  int rsb_max=-30000;
  int lsb_min= 30000;
  int overallascent=-30000;
  int overalldescent=30000;

  
  /* First, check for a correct ID */
  i=CheckForFontID(FontID);
  if (i!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NullBBox);
  }
  
  /* If no AFM info is present, we return an error */
  if (pFontBase->pFontArray[FontID].pAFMData==NULL) {
    T1_errno=T1ERR_NO_AFM_DATA;
    return( NullBBox);
  }

  /* Get length of string: */
  if (len<0 || string==NULL) {  /* invalid length or NULL-pointer */
    T1_errno=T1ERR_INVALID_PARAMETER;
    return(NullBBox);
  }
  if (len==0) /* should be computed assuming "normal" 0-terminated string */
    no_chars=strlen(string);
  else        /* use value given on command line */
    no_chars=len;
  
  spacewidth=
    T1_GetCharWidth(FontID,pFontBase->pFontArray[FontID].space_position)+spaceoff;
  
  /* Accumulate metrics: */
  for (i=0; i<no_chars; i++){
    if (string[i]==pFontBase->pFontArray[FontID].space_position)
      curr_width +=spacewidth;
    else{
      tmp_BBox=T1_GetCharBBox( FontID, string[i]);
      if (curr_width+tmp_BBox.llx < lsb_min)
	lsb_min=curr_width+tmp_BBox.llx;
      if (curr_width+tmp_BBox.urx > rsb_max)
	rsb_max=curr_width+tmp_BBox.urx;
      if (tmp_BBox.lly < overalldescent)
	overalldescent=tmp_BBox.lly;
      if (tmp_BBox.ury > overallascent)
	overallascent=tmp_BBox.ury;
      curr_width +=T1_GetCharWidth( FontID, string[i]);
      if ((i<no_chars-1) && (kerning != 0))
	curr_width += T1_GetKerning( FontID, string[i], string[i+1]);
    }
  }

  ResultBBox.llx=lsb_min;
  ResultBBox.lly=overalldescent;
  ResultBBox.urx=rsb_max;
  ResultBBox.ury=overallascent;
  
  return( ResultBBox);
  
}


/* T1_GetMetricsInfo(): Return a structure containing metrics information
   about the string to the user. */
METRICSINFO T1_GetMetricsInfo( int FontID, char *string,
			       int len, long spaceoff, int kerning)
{

  BBox NullBBox= { 0, 0, 0, 0}; /* A bounding box containing all 0's. */
  BBox tmp_BBox= { 0, 0, 0, 0}; 


  int i;
  int no_chars;
  
  int curr_width=0;
  int spacewidth=0;
  
  int rsb_max=-30000;
  int lsb_min= 30000;
  int overallascent=-30000;
  int overalldescent=30000;

  static METRICSINFO metrics={ 0, {0, 0, 0, 0}, 0, NULL};

  unsigned char *ustring;

  
  ustring=(unsigned char *) string;
  
  /* Reset struct: */
  metrics.width=0;
  metrics.bbox=NullBBox;