graphics/psdrv/afm.c

   1 /*
   2  *      Adobe Font Metric (AFM) file parsing
   3  *      See http://www.adobe.com/supportservice/devrelations/PDFS/TN/5004.AFM_Spec.pdf
   4  *
   5  *      Copyright 1998  Huw D M Davies
   6  *
   7  */
   8
   9 #include <string.h>
  10 #include "winnt.h" /* HEAP_ZERO_MEMORY */
  11 #include "psdrv.h"
  12 #include "options.h"
  13 #include "debug.h"
  14 #include "heap.h"
  15 #include <ctype.h>
  16
  17 /* ptr to fonts for which we have afm files */
  18 FONTFAMILY *PSDRV_AFMFontList = NULL;
  19
  20
  21 /***********************************************************
  22  *
  23  *      PSDRV_AFMGetCharMetrics
  24  *
  25  * Parses CharMetric section of AFM file.
  26  *
  27  * Actually only collects the widths of numbered chars and puts then in
  28  * afm->CharWidths.
  29  */
  30 static void PSDRV_AFMGetCharMetrics(AFM *afm, FILE *fp)
  31 {
  32     char line[256], valbuf[256];
  33     char *cp, *item, *value, *curpos, *endpos;
  34     int i;
  35     AFMMETRICS **insert = &afm->Metrics, *metric;
  36
  37     for(i = 0; i < afm->NumofMetrics; i++) {
  38
  39         if(!fgets(line, sizeof(line), fp)) {
  40            ERR(psdrv, "Unexpected EOF\n");
  41            return;
  42         }
  43
  44         metric = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
  45                                       sizeof(AFMMETRICS) );
  46         insert = &metric->next;
  47
  48         cp = line + strlen(line);
  49         do {
  50             *cp = '\0';
  51             cp--;
  52         } while(cp > line && isspace(*cp));
  53
  54         curpos = line;
  55         while(*curpos) {
  56             item = curpos;
  57             while(isspace(*item))
  58                 item++;
  59             value = strpbrk(item, " \t");
  60             while(isspace(*value))
  61                 value++;
  62             cp = endpos = strchr(value, ';');
  63             while(isspace(*--cp))
  64                 ;
  65             memcpy(valbuf, value, cp - value + 1);
  66             valbuf[cp - value + 1] = '\0';
  67             value = valbuf;
  68
  69             if(!strncmp(item, "C ", 2)) {
  70                 value = strchr(item, ' ');
  71                 sscanf(value, " %d", &metric->C);
  72
  73             } else if(!strncmp(item, "CH ", 3)) {
  74                 value = strrchr(item, ' ');
  75                 sscanf(value, " %x", &metric->C);
  76             }
  77
  78             else if(!strncmp("WX ", item, 3) || !strncmp("W0X ", item, 4)) {
  79                 sscanf(value, "%f", &metric->WX);
  80                 if(metric->C >= 0 && metric->C <= 0xff)
  81                     afm->CharWidths[metric->C] = metric->WX;
  82             }
  83
  84             else if(!strncmp("N ", item, 2)) {
  85                 metric->N = HEAP_strdupA( PSDRV_Heap, 0, value);
  86             }
  87
  88             else if(!strncmp("B ", item, 2)) {
  89                 sscanf(value, "%f%f%f%f", &metric->B.llx, &metric->B.lly,
  90                                           &metric->B.urx, &metric->B.ury);
  91
  92                 /* Store height of Aring to use as lfHeight */
  93                 if(metric->N && !strncmp(metric->N, "Aring", 5))
  94                     afm->FullAscender = metric->B.ury;
  95             }
  96
  97             /* Ligatures go here... */
  98
  99             curpos = endpos + 1;
 100         }
 101
 102 #if 0
 103         TRACE(psdrv, "Metrics for '%s' WX = %f B = %f,%f - %f,%f\n",
 104               metric->N, metric->WX, metric->B.llx, metric->B.lly,
 105               metric->B.urx, metric->B.ury);
 106 #endif
 107     }
 108
 109     return;
 110 }
 111
 112 /***********************************************************
 113  *
 114  *      PSDRV_AFMParse
 115  *
 116  * Fills out an AFM structure and associated substructures (see psdrv.h)
 117  * for a given AFM file. All memory is allocated from the process heap.
 118  * Returns a ptr to the AFM structure or NULL on error.
 119  *
 120  * This is not complete (we don't handle kerning yet) and not efficient
 121  */
 122 static AFM *PSDRV_AFMParse(char const *file)
 123 {
 124     FILE *fp;
 125     char buf[256];
 126     char *value;
 127     AFM *afm;
 128     char *cp;
 129
 130     TRACE(psdrv, "parsing '%s'\n", file);
 131
 132     if((fp = fopen(file, "r")) == NULL) {
 133         MSG("Can't open AFM file '%s'. Please check wine.conf .\n", file);
 134         return NULL;
 135     }
 136
 137     afm = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(AFM));
 138     if(!afm) {
 139         fclose(fp);
 140         return NULL;
 141     }
 142
 143     while(fgets(buf, sizeof(buf), fp)) {
 144         cp = buf + strlen(buf);
 145         do {
 146             *cp = '\0';
 147             cp--;
 148         } while(cp > buf && isspace(*cp));
 149
 150         value = strchr(buf, ' ');
 151         if(value)
 152             while(isspace(*value))
 153                 value++;
 154
 155         if(!strncmp("FontName", buf, 8)) {
 156             afm->FontName = HEAP_strdupA(PSDRV_Heap, 0, value);
 157             continue;
 158         }
 159
 160         if(!strncmp("FullName", buf, 8)) {
 161             afm->FullName = HEAP_strdupA(PSDRV_Heap, 0, value);
 162             continue;
 163         }
 164
 165         if(!strncmp("FamilyName", buf, 10)) {
 166             afm->FamilyName = HEAP_strdupA(PSDRV_Heap, 0, value);
 167             continue;
 168         }
 169
 170         if(!strncmp("Weight", buf, 6)) {
 171             if(!strncmp("Roman", value, 5) || !strncmp("Medium", value, 6)
 172                || !strncmp("Book", value, 4) || !strncmp("Regular", value, 7)
 173                || !strncmp("Normal", value, 6))
 174                 afm->Weight = FW_NORMAL;
 175             else if(!strncmp("Demi", value, 4))
 176                 afm->Weight = FW_DEMIBOLD;
 177             else if(!strncmp("Bold", value, 4))
 178                 afm->Weight = FW_BOLD;
 179             else if(!strncmp("Light", value, 5))
 180                 afm->Weight = FW_LIGHT;
 181             else {
 182                 FIXME(psdrv, "Unkown AFM Weight '%s'\n", value);
 183                 afm->Weight = FW_NORMAL;
 184             }
 185             continue;
 186         }
 187
 188         if(!strncmp("ItalicAngle", buf, 11)) {
 189             sscanf(value, "%f", &(afm->ItalicAngle));
 190             continue;
 191         }
 192
 193         if(!strncmp("IsFixedPitch", buf, 12)) {
 194             if(!strncasecmp("false", value, 5))
 195                 afm->IsFixedPitch = FALSE;
 196             else
 197                 afm->IsFixedPitch = TRUE;
 198             continue;
 199         }
 200
 201         if(!strncmp("FontBBox", buf, 8)) {
 202             sscanf(value, "%f %f %f %f", &(afm->FontBBox.llx),
 203                    &(afm->FontBBox.lly), &(afm->FontBBox.urx),
 204                    &(afm->FontBBox.ury) );
 205             continue;
 206         }
 207
 208         if(!strncmp("UnderlinePosition", buf, 17)) {
 209             sscanf(value, "%f", &(afm->UnderlinePosition) );
 210             continue;
 211         }
 212
 213         if(!strncmp("UnderlineThickness", buf, 18)) {
 214             sscanf(value, "%f", &(afm->UnderlineThickness) );
 215             continue;
 216         }
 217
 218         if(!strncmp("CapHeight", buf, 9)) {
 219             sscanf(value, "%f", &(afm->CapHeight) );
 220             continue;
 221         }
 222
 223         if(!strncmp("XHeight", buf, 7)) {
 224             sscanf(value, "%f", &(afm->XHeight) );
 225             continue;
 226         }
 227
 228         if(!strncmp("Ascender", buf, 8)) {
 229             sscanf(value, "%f", &(afm->Ascender) );
 230             continue;
 231         }
 232
 233         if(!strncmp("Descender", buf, 9)) {
 234             sscanf(value, "%f", &(afm->Descender) );
 235             continue;
 236         }
 237
 238         if(!strncmp("StartCharMetrics", buf, 16)) {
 239             sscanf(value, "%d", &(afm->NumofMetrics) );
 240             PSDRV_AFMGetCharMetrics(afm, fp);
 241             continue;
 242         }
 243
 244         if(!strncmp("EncodingScheme", buf, 14)) {
 245             afm->EncodingScheme = HEAP_strdupA(PSDRV_Heap, 0, value);
 246             continue;
 247         }
 248
 249     }
 250     fclose(fp);
 251
 252     if(afm->Ascender == 0.0)
 253         afm->Ascender = afm->FontBBox.ury;
 254     if(afm->Descender == 0.0)
 255         afm->Descender = afm->FontBBox.lly;
 256     if(afm->FullAscender == 0.0)
 257         afm->FullAscender = afm->Ascender;
 258
 259     return afm;
 260 }
 261
 262 /***********************************************************
 263  *
 264  *      PSDRV_FreeAFMList
 265  *
 266  * Frees the family and afmlistentry structures in list head
 267  */
 268 void PSDRV_FreeAFMList( FONTFAMILY *head )
 269 {
 270     AFMLISTENTRY *afmle, *nexta;
 271     FONTFAMILY *family, *nextf;
 272
 273     for(nextf = family = head; nextf; family = nextf) {
 274         for(nexta = afmle = family->afmlist; nexta; afmle = nexta) {
 275             nexta = afmle->next;
 276             HeapFree( PSDRV_Heap, 0, afmle );
 277         }
 278         nextf = family->next;
 279         HeapFree( PSDRV_Heap, 0, family );
 280     }
 281     return;
 282 }
 283
 284
 285 /***********************************************************
 286  *
 287  *      PSDRV_FindAFMinList
 288  * Returns ptr to an AFM if name (which is a PS font name) exists in list
 289  * headed by head.
 290  */
 291 AFM *PSDRV_FindAFMinList(FONTFAMILY *head, char *name)
 292 {
 293     FONTFAMILY *family;
 294     AFMLISTENTRY *afmle;
 295
 296     for(family = head; family; family = family->next) {
 297         for(afmle = family->afmlist; afmle; afmle = afmle->next) {
 298             if(!strcmp(afmle->afm->FontName, name))
 299                 return afmle->afm;
 300         }
 301     }
 302     return NULL;
 303 }
 304
 305 /***********************************************************
 306  *
 307  *      PSDRV_AddAFMtoList
 308  *
 309  * Adds an afm to the list whose head is pointed to by head. Creates new
 310  * family node if necessary and always creates a new AFMLISTENTRY.
 311  */
 312 void PSDRV_AddAFMtoList(FONTFAMILY **head, AFM *afm)
 313 {
 314     FONTFAMILY *family = *head;
 315     FONTFAMILY **insert = head;
 316     AFMLISTENTRY *tmpafmle, *newafmle;
 317
 318     newafmle = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY,
 319                            sizeof(*newafmle));
 320     newafmle->afm = afm;
 321
 322     while(family) {
 323         if(!strcmp(family->FamilyName, afm->FamilyName))
 324             break;
 325         insert = &(family->next);
 326         family = family->next;
 327     }
 328
 329     if(!family) {
 330         family = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY,
 331                            sizeof(*family));
 332         *insert = family;
 333         family->FamilyName = HEAP_strdupA(PSDRV_Heap, 0,
 334                                           afm->FamilyName);
 335         family->afmlist = newafmle;
 336         return;
 337     }
 338
 339     tmpafmle = family->afmlist;
 340     while(tmpafmle->next)
 341         tmpafmle = tmpafmle->next;
 342
 343     tmpafmle->next = newafmle;
 344
 345     return;
 346 }
 347
 348 /**********************************************************
 349  *
 350  *      PSDRV_ReencodeCharWidths
 351  *
 352  * Re map the CharWidths field of the afm to correspond to an ANSI encoding
 353  *
 354  */
 355 static void PSDRV_ReencodeCharWidths(AFM *afm)
 356 {
 357     int i;
 358     AFMMETRICS *metric;
 359
 360     for(i = 0; i < 256; i++) {
 361         if(isalnum(i))
 362             continue;
 363         if(PSDRV_ANSIVector[i] == NULL) {
 364             afm->CharWidths[i] = 0.0;
 365             continue;
 366         }
 367         for(metric = afm->Metrics; metric; metric = metric->next) {
 368             if(!strcmp(metric->N, PSDRV_ANSIVector[i])) {
 369                 afm->CharWidths[i] = metric->WX;
 370                 break;
 371             }
 372         }
 373         if(!metric) {
 374             WARN(psdrv, "Couldn't find glyph '%s' in font '%s'\n",
 375                  PSDRV_ANSIVector[i], afm->FontName);
 376             afm->CharWidths[i] = 0.0;
 377         }
 378     }
 379     return;
 380 }
 381
 382 /***********************************************************
 383  *
 384  *      PSDRV_afmfilesCallback
 385  *
 386  * Callback for PROFILE_EnumerateWineIniSection
 387  * Try to parse AFM file `value', alter the CharWidths field of afm struct if
 388  * the font is using AdobeStandardEncoding to correspond to WinANSI, then add
 389  * afm to system font list.
 390  */
 391 static void PSDRV_afmfilesCallback(char const *key, char const *value,
 392 void *user)
 393 {
 394     AFM *afm;
 395
 396     afm = PSDRV_AFMParse(value);
 397     if(afm) {
 398         if(afm->EncodingScheme &&
 399            !strcmp(afm->EncodingScheme, "AdobeStandardEncoding")) {
 400             PSDRV_ReencodeCharWidths(afm);
 401         }
 402         PSDRV_AddAFMtoList(&PSDRV_AFMFontList, afm);
 403     }
 404     return;
 405 }
 406
 407
 408 /***********************************************************
 409  *
 410  *      PSDRV_DumpFontList
 411  *
 412  */
 413 static void PSDRV_DumpFontList(void)
 414 {
 415     FONTFAMILY *family;
 416     AFMLISTENTRY *afmle;
 417
 418     for(family = PSDRV_AFMFontList; family; family = family->next) {
 419         TRACE(psdrv, "Family '%s'\n", family->FamilyName);
 420         for(afmle = family->afmlist; afmle; afmle = afmle->next) {
 421             TRACE(psdrv, "\tFontName '%s'\n", afmle->afm->FontName);
 422         }
 423     }
 424     return;
 425 }
 426
 427
 428 /***********************************************************
 429  *
 430  *      PSDRV_GetFontMetrics
 431  *
 432  * Only exported function in this file. Parses all afm files listed in
 433  * [afmfiles] of wine.conf .
 434  */
 435 BOOL PSDRV_GetFontMetrics(void)
 436 {
 437     PROFILE_EnumerateWineIniSection( "afmfiles", PSDRV_afmfilesCallback, NULL);
 438     PSDRV_DumpFontList();
 439     return TRUE;
 440 }
 441