t1finfo.c

source code: Covert TXT to PDF

/*--------------------------------------------------------------------------
  ----- File:        t1finfo.c 
  ----- Author:      Rainer Menzner ([e-mail])
  ----- Date:        2001-06-10
  ----- Description: This file is part of the t1-library. It contains
                     functions for accessing afm-data and some other
		     fontinformation data.
  ----- Copyright:   t1lib is copyrighted (c) Rainer Menzner, 1996-2001. 
                     As of version 0.5, t1lib is distributed under the
		     GNU General Public Library Lincense. The
		     conditions can be found in the files LICENSE and
		     LGPL, which should reside in the toplevel
		     directory of the distribution.  Please note that 
		     there are parts of t1lib that are subject to
		     other licenses:
		     The parseAFM-package is copyrighted by Adobe Systems
		     Inc.
		     The type1 rasterizer is copyrighted by IBM and the
		     X11-consortium.
  ----- Warranties:  Of course, there's NO WARRANTY OF ANY KIND :-)
  ----- Credits:     I want to thank IBM and the X11-consortium for making
                     their rasterizer freely available.
		     Also thanks to Piet Tutelaers for his ps2pk, from
		     which I took the rasterizer sources in a format
		     independent from X11.
                     Thanks to all people who make free software living!
--------------------------------------------------------------------------*/
  
#define T1FINFO_C


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#if defined(_MSC_VER)
# include <io.h>
# include <sys/types.h>
# include <sys/stat.h>
#else
# include <unistd.h>
#endif
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "../type1/ffilest.h" 
#include "../type1/types.h"
#include "parseAFM.h" 
#include "../type1/objects.h"
#include "../type1/spaces.h"
#include "../type1/util.h"
#include "../type1/fontfcn.h"
#include "../type1/regions.h"


#include "t1types.h"
#include "t1extern.h"
#include "t1finfo.h"
#include "t1base.h"
#include "t1misc.h"
#include "t1set.h"
#include "t1load.h"


/* The following variable controls the computation of the bbox internal
   to T1_GetMetricsInfo(). Its influence may be overridden by the
   global variable ForceAFMBBox: */
static int ForceAFMBBoxInternal=0;


extern int ForceAFMBBox;
extern char *t1_get_abort_message( int number);
  

/* int T1_GetKerning(): This function returns the amount of kerning that
   is specified in the afm-file for the supplied character-pair. If an
   an extension has been applied to the font in question, this is taken
   into account.
   If for whatever reason there's no afm information available (that's not
   deadly), simply 0 is returned, indicating that no kerning should be used.
   The value returned is meant to be in character space coordinates. Thus,
   it must be transformed to be applicable in device space.
   */
int T1_GetKerning( int FontID, char char1, char char2)
{
  METRICS_ENTRY entry;
  METRICS_ENTRY *target_pair=NULL;
  

  /* Check whether font is loaded: */
  if (CheckForFontID(FontID)!=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);
  }

  /* if there's no kerning info, return immediately */
  if (pFontBase->pFontArray[FontID].KernMapSize==0)
    return( 0);
  
  entry.chars=(char1<<8) | char2;
  if ((target_pair=(METRICS_ENTRY *)
       bsearch( &entry, pFontBase->pFontArray[FontID].pKernMap,
		(size_t) pFontBase->pFontArray[FontID].KernMapSize,
		sizeof(METRICS_ENTRY),
		&cmp_METRICS_ENTRY))==NULL)
    return(0);
  else
    return( target_pair->hkern * pFontBase->pFontArray[FontID].extend);
  
}



/* int T1_GetCharWidth(): This function returns the characterwidth
   specified in the .afm-file. If no .afm-file is loaded for that font,
   0 is returned. Note that if one tries to raster strings, afm data
   must always be available. The returned character width is corrected
   using  a possibly applied font extension!
   */
int T1_GetCharWidth( int FontID, char char1)
{
  unsigned char uchar1;

  uchar1=(unsigned char) char1;
  
  /* Check whether font is loaded: */
  if (CheckForFontID(FontID)!=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);
  }
  
  /* return appriate value */
  if (pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]>0) { /* ordinary character */
    return((int) ((pFontBase->pFontArray[FontID].pAFMData->cmi[pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]-1].wx) * pFontBase->pFontArray[FontID].extend));
  }
  else if (pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]<0) { /* composite character */
    return((int) ((pFontBase->pFontArray[FontID].pAFMData->ccd[-(pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]+1)].wx) * pFontBase->pFontArray[FontID].extend));
  }
  else { /* undefined or .notdef */
    return(0);
  }
  
}



/* T1_GetCharBBox(): Get the BoundingBox of specified character. If an
   extension factor has been applied to the font in question, this
   is taken into account. However, a slant factor which has been applied
   to the font, also affects the bounding box of a character. The
   only way to determine its influence on the character bounding box
   is to compute the exact shape of that slanted character. There's no
   simple way to extract the new bounding box from the former bounding
   box. Thus, if a font has been slanted, the characters outline itself
   is examined. Since this must be done at 1000 bp it takes considerably
   longer than reading afm data. */
BBox T1_GetCharBBox( int FontID, char char1)
{

  struct region *area;
  struct XYspace *S;    
  int mode=0;
  int i;
  
  BBox NullBBox= { 0, 0, 0, 0}; /* A bounding box containing all 0's. */
  BBox ResultBox= { 0, 0, 0, 0}; /* The Box returned if char is found */
  
  unsigned char uchar1;


  /* We return to this if something goes wrong deep in the rasterizer */
  if ((i=setjmp( stck_state))!=0) {
    T1_errno=T1ERR_TYPE1_ABORT;
    sprintf( err_warn_msg_buf, "t1_abort: Reason: %s",
	     t1_get_abort_message( i));
    T1_PrintLog( "T1_GetCharBBox()", err_warn_msg_buf,
	       T1LOG_ERROR);
    return( NullBBox);
  }

  
  uchar1=(unsigned char) char1;
  
  /* Check whether font is loaded: */
  if (CheckForFontID(FontID)!=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);
  }
  
  
  /* Check for a font slant */
  if ((pFontBase->pFontArray[FontID].slant!=0.0)
      &&(ForceAFMBBox==0)
      &&(ForceAFMBBoxInternal==0)){
    /* We have a font slant -> character outline must be examined in order
       to determine bounding box */
    /* Set up an identity charspace matrix 
       and take a slant and an extension into account */
    /* And make it permanent, to plug a memory leak */
    S=(struct XYspace *)IDENTITY;
    S=(struct XYspace *)Permanent
      (Transform(S, pFontBase->pFontArray[FontID].FontTransform[0],
		 pFontBase->pFontArray[FontID].FontTransform[1],
		 pFontBase->pFontArray[FontID].FontTransform[2],
		 pFontBase->pFontArray[FontID].FontTransform[3]));
    /* Genrate an edgelist for the current character at size 1000bp
       using current transformation and encoding: */
    area=fontfcnB( FontID, 0, S,
		   pFontBase->pFontArray[FontID].pFontEnc,
		   (int) uchar1, &mode,
		   pFontBase->pFontArray[FontID].pType1Data,
		   DO_RASTER);
    /* Read out bounding box */
    ResultBox.llx =area->xmin;
    ResultBox.urx =area->xmax;
    ResultBox.lly =area->ymin;
    ResultBox.ury =area->ymax;
    
    /* Reset AFM-switch and return BBox */
    ForceAFMBBoxInternal=0;
    /* make sure to destroy 'area' before leaving! */
    KillRegion (area);
    /* make sure to free S */
    if (S) {
      KillSpace (S);
    }
    return(ResultBox);
  }
  else{
    /* Assign bounding box for the different cases: */
    /* Check if character is  */
    if (pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]>0) { /* ordinary char */
      ResultBox=(pFontBase->pFontArray[FontID].pAFMData->cmi[pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]-1].charBBox);
    }
    else if (pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]<0) { /* composite char */
      ResultBox=(pFontBase->pFontArray[FontID].pAFMData->ccd[-(pFontBase->pFontArray[FontID].pEncMap[(int) uchar1]+1)].charBBox);
    }
    else { /* undefined char */
      return(NullBBox);
    }
    
    /* .. and apply transformations: */
    ResultBox.llx *=pFontBase->pFontArray[FontID].extend;
    ResultBox.urx *=pFontBase->pFontArray[FontID].extend;
    
    return(ResultBox);
  }
}



/* int T1_GetUnderlinePosition(): Return underline position of specified
   font in charspace units. If 0 is returned, it indicated that the font
   is not yet loaded into memory. or an invalid ID has been specified. */
float T1_GetUnderlinePosition( int FontID)
{
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(0.0);
  }
  
  return((float)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[UNDERLINEPOSITION].value.data.real));
}



/* int T1_GetUnderlineThickness(): Return underline thickness of specified
   font in charspace units. If 0 is returned, it indicated that the font
   is not yet loaded into memory. or an invalid ID has been specified. */
float T1_GetUnderlineThickness( int FontID)
{
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(0.0);
  }
  
  return((float)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[UNDERLINETHICKNESS].value.data.real));
}


/* int T1_ItalicAngle(): Return underline position of specified
   font in charspace units. If 0.0 is returned, it indicated that the font
   is not yet loaded into memory. or an invalid ID has been specified. */
float T1_GetItalicAngle( int FontID)
{
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(0.0);
  }
  
  return((float)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ITALICANGLE].value.data.real));
}



/* int T1_GetUnderlinePosition(): Return underline position of specified
   font in charspace units. If 0 is returned, it indicated that the font
   is not yet loaded into memory. or an invalid ID has been specified. */
int T1_GetIsFixedPitch( int FontID)
{
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(0.0);
  }
  
  return((int)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[ISFIXEDPITCH].value.data.boolean));
}



/* char *T1_GetFontName( FontID): Get the PostScript FontName of
   the  font dictionary associated with the specified font, or NULL if
   an error occurs. */
char *T1_GetFontName( int FontID)
{
  static char fontname[MAXPSNAMELEN];
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }
  
  strncpy(fontname,
	  (char *)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FONTNAME].value.data.nameP),
	  pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FONTNAME].value.len);
  fontname[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FONTNAME].value.len]=0;
    
  return(fontname);
  
}


/* char *T1_GetFullName( FontID): Get the Full Name from
   the  font dictionary associated with the specified font, or NULL if
   an error occurs. */
char *T1_GetFullName( int FontID)
{
  static char fullname[MAXPSNAMELEN];
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }
  
  strncpy(fullname,
	  (char *)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FULLNAME].value.data.nameP),
	  pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FULLNAME].value.len);
  fullname[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FULLNAME].value.len]=0;
    
  return(fullname);
  
}


/* char *T1_GetFamilyName( FontID): Get the Family Name of
   the  font dictionary associated with the specified font, or NULL if
   an error occurs. */
char *T1_GetFamilyName( int FontID)
{
  static char familyname[MAXPSNAMELEN];
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }
  
  strncpy(familyname,
	  (char *)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FAMILYNAME].value.data.nameP),
	  pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FAMILYNAME].value.len);
  familyname[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[FAMILYNAME].value.len]=0;
    
  return(familyname);
  
}


/* char *T1_GetWeight( FontID): Get the Weight entry from
   the  font dictionary associated with the specified font, or NULL if
   an error occurs. */
char *T1_GetWeight( int FontID)
{
  static char weight[128];
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }
  
  strncpy(weight,
	  (char *)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[WEIGHT].value.data.nameP),
	  pFontBase->pFontArray[FontID].pType1Data->fontInfoP[WEIGHT].value.len);
  weight[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[WEIGHT].value.len]=0;
    
  return(weight);
  
}


/* char *T1_GetFontName( FontID): Get the Version entry from 
   the  font dictionary associated with the specified font, or NULL if
   an error occurs. */
char *T1_GetVersion( int FontID)
{
  static char version[2048];
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;
    return(NULL);
  }
  
  strncpy(version,
	  (char *)(pFontBase->pFontArray[FontID].pType1Data->fontInfoP[VERSION].value.data.nameP),
	  pFontBase->pFontArray[FontID].pType1Data->fontInfoP[VERSION].value.len);
  version[pFontBase->pFontArray[FontID].pType1Data->fontInfoP[VERSION].value.len]=0;
    
  return(version);
  
}


/* char *T1_GetNotice( FontID): Get the Notice entry from
   the  font dictionary associated with the specified font, or NULL if
   an error occurs. */
char *T1_GetNotice( int FontID)
{
  static char notice[2048];
  
  if (CheckForFontID(FontID)!=1){
    T1_errno=T1ERR_INVALID_FONTID;