Fix shell32.ExtractIcon with A->W and 16 -> 32 calls.
[wine] / dlls / wineps / afm.c
index c01d621..fbc0a33 100644 (file)
 /*
- *     Adobe Font Metric (AFM) file parsing
- *     See http://www.adobe.com/supportservice/devrelations/PDFS/TN/5004.AFM_Spec.pdf
+ *     Font metric functions common to Type 1 (AFM) and TrueType font files.
+ *     Functions specific to Type 1 and TrueType fonts are in type1afm.c and
+ *     truetype.c respectively.
  *
  *     Copyright 1998  Huw D M Davies
- * 
- */
-
-#include <string.h>
-#include <stdio.h>
-#include "winnt.h" /* HEAP_ZERO_MEMORY */
-#include "psdrv.h"
-#include "options.h"
-#include "debugtools.h"
-#include "heap.h"
-
-DEFAULT_DEBUG_CHANNEL(psdrv);
-#include <ctype.h>
-
-/* ptr to fonts for which we have afm files */
-FONTFAMILY *PSDRV_AFMFontList = NULL;
-
-
-/***********************************************************
+ *     Copyright 2001  Ian Pilcher
  *
- *     PSDRV_AFMGetCharMetrics
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * Parses CharMetric section of AFM file.
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  *
- * Actually only collects the widths of numbered chars and puts then in
- * afm->CharWidths.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-static void PSDRV_AFMGetCharMetrics(AFM *afm, FILE *fp)
-{
-    char line[256], valbuf[256];
-    char *cp, *item, *value, *curpos, *endpos;
-    int i;
-    AFMMETRICS *metric;
-
-    afm->Metrics = metric = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
-                                       afm->NumofMetrics * sizeof(AFMMETRICS) );
-    for(i = 0; i < afm->NumofMetrics; i++, metric++) {
-
-        if(!fgets(line, sizeof(line), fp)) {
-          ERR("Unexpected EOF\n");
-          return;
-       }
-       cp = line + strlen(line);
-       do {
-           *cp = '\0';
-           cp--;
-       } while(cp > line && isspace(*cp));
-
-       curpos = line;
-       while(*curpos) {
-           item = curpos;
-           while(isspace(*item))
-               item++;
-           value = strpbrk(item, " \t");
-           while(isspace(*value))
-               value++;
-           cp = endpos = strchr(value, ';');
-           while(isspace(*--cp))
-               ;
-           memcpy(valbuf, value, cp - value + 1);
-           valbuf[cp - value + 1] = '\0';
-           value = valbuf;
-
-           if(!strncmp(item, "C ", 2)) {
-               value = strchr(item, ' ');
-               sscanf(value, " %d", &metric->C);
-
-           } else if(!strncmp(item, "CH ", 3)) {
-               value = strrchr(item, ' ');
-               sscanf(value, " %x", &metric->C);
-           }
-
-           else if(!strncmp("WX ", item, 3) || !strncmp("W0X ", item, 4)) {
-               sscanf(value, "%f", &metric->WX);
-               if(metric->C >= 0 && metric->C <= 0xff)
-                   afm->CharWidths[metric->C] = metric->WX;
-           }
-
-           else if(!strncmp("N ", item, 2)) {
-                strncpy( metric->N, value, sizeof(metric->N) );
-           }
-
-           else if(!strncmp("B ", item, 2)) {
-               sscanf(value, "%f%f%f%f", &metric->B.llx, &metric->B.lly,
-                                         &metric->B.urx, &metric->B.ury);
-
-               /* Store height of Aring to use as lfHeight */
-               if(metric->N && !strncmp(metric->N, "Aring", 5))
-                   afm->FullAscender = metric->B.ury;
-           }
-
-           /* Ligatures go here... */
-
-           curpos = endpos + 1;
-       }
-
-#if 0  
-       TRACE("Metrics for '%s' WX = %f B = %f,%f - %f,%f\n",
-             metric->N, metric->WX, metric->B.llx, metric->B.lly,
-             metric->B.urx, metric->B.ury);
-#endif
-    }
-
-    return;
-}
-
-/***********************************************************
- *
- *     PSDRV_AFMParse
- *
- * Fills out an AFM structure and associated substructures (see psdrv.h)
- * for a given AFM file. All memory is allocated from the process heap. 
- * Returns a ptr to the AFM structure or NULL on error.
- *
- * This is not complete (we don't handle kerning yet) and not efficient
- */
-static AFM *PSDRV_AFMParse(char const *file)
-{
-    FILE *fp;
-    char buf[256];
-    char *value;
-    AFM *afm;
-    char *cp;
 
-    TRACE("parsing '%s'\n", file);
+#include "config.h"
 
-    if((fp = fopen(file, "r")) == NULL) {
-        MESSAGE("Can't open AFM file '%s'. Please check wine.conf .\n", file);
-        return NULL;
-    }
-
-    afm = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(AFM));
-    if(!afm) {
-        fclose(fp);
-        return NULL;
-    }
-
-    while(fgets(buf, sizeof(buf), fp)) {
-       cp = buf + strlen(buf);
-       do {
-           *cp = '\0';
-           cp--;
-       } while(cp > buf && isspace(*cp));
-
-        value = strchr(buf, ' ');
-       if(value)
-           while(isspace(*value))
-               value++;
-
-       if(!strncmp("FontName", buf, 8)) {
-           afm->FontName = HEAP_strdupA(PSDRV_Heap, 0, value);
-           continue;
-       }
-
-       if(!strncmp("FullName", buf, 8)) {
-           afm->FullName = HEAP_strdupA(PSDRV_Heap, 0, value);
-           continue;
-       }
-
-       if(!strncmp("FamilyName", buf, 10)) {
-           afm->FamilyName = HEAP_strdupA(PSDRV_Heap, 0, value);
-           continue;
-       }
-       
-       if(!strncmp("Weight", buf, 6)) {
-           if(!strncmp("Roman", value, 5) || !strncmp("Medium", value, 6)
-              || !strncmp("Book", value, 4) || !strncmp("Regular", value, 7)
-              || !strncmp("Normal", value, 6))
-               afm->Weight = FW_NORMAL;
-           else if(!strncmp("Demi", value, 4))
-               afm->Weight = FW_DEMIBOLD;
-           else if(!strncmp("Bold", value, 4))
-               afm->Weight = FW_BOLD;
-           else if(!strncmp("Light", value, 5))
-               afm->Weight = FW_LIGHT;
-           else if(!strncmp("Black", value, 5))
-               afm->Weight = FW_BLACK;
-           else {
-               FIXME("Unkown AFM Weight '%s'\n", value);
-               afm->Weight = FW_NORMAL;
-           }
-           continue;
-       }
-
-       if(!strncmp("ItalicAngle", buf, 11)) {
-           sscanf(value, "%f", &(afm->ItalicAngle));
-           continue;
-       }
-
-       if(!strncmp("IsFixedPitch", buf, 12)) {
-           if(!strncasecmp("false", value, 5))
-               afm->IsFixedPitch = FALSE;
-           else
-               afm->IsFixedPitch = TRUE;
-           continue;
-       }
-
-       if(!strncmp("FontBBox", buf, 8)) {
-           sscanf(value, "%f %f %f %f", &(afm->FontBBox.llx), 
-                  &(afm->FontBBox.lly), &(afm->FontBBox.urx), 
-                  &(afm->FontBBox.ury) );
-           continue;
-       }
-
-       if(!strncmp("UnderlinePosition", buf, 17)) {
-           sscanf(value, "%f", &(afm->UnderlinePosition) );
-           continue;
-       }
-
-       if(!strncmp("UnderlineThickness", buf, 18)) {
-           sscanf(value, "%f", &(afm->UnderlineThickness) );
-           continue;
-       }
-
-       if(!strncmp("CapHeight", buf, 9)) {
-           sscanf(value, "%f", &(afm->CapHeight) );
-           continue;
-       }
-
-       if(!strncmp("XHeight", buf, 7)) {
-           sscanf(value, "%f", &(afm->XHeight) );
-           continue;
-       }
-
-       if(!strncmp("Ascender", buf, 8)) {
-           sscanf(value, "%f", &(afm->Ascender) );
-           continue;
-       }
+#include <string.h>
 
-       if(!strncmp("Descender", buf, 9)) {
-           sscanf(value, "%f", &(afm->Descender) );
-           continue;
-       }
+#include "psdrv.h"
+#include "wine/debug.h"
 
-       if(!strncmp("StartCharMetrics", buf, 16)) {
-           sscanf(value, "%d", &(afm->NumofMetrics) );
-           PSDRV_AFMGetCharMetrics(afm, fp);
-           continue;
-       }
+WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
 
-       if(!strncmp("EncodingScheme", buf, 14)) {
-           afm->EncodingScheme = HEAP_strdupA(PSDRV_Heap, 0, value);
-           continue;
-       }
+/* ptr to fonts for which we have afm files */
+FONTFAMILY *PSDRV_AFMFontList = NULL;
 
-    }
-    fclose(fp);
-
-    if(afm->FontName == NULL)
-        WARN("%s contains no FontName.\n", file);
-    if(afm->FullName == NULL)
-        afm->FullName = HEAP_strdupA(PSDRV_Heap, 0, afm->FontName);
-    if(afm->FamilyName == NULL)
-        afm->FamilyName = HEAP_strdupA(PSDRV_Heap, 0, afm->FontName);      
-    if(afm->Ascender == 0.0)
-        afm->Ascender = afm->FontBBox.ury;
-    if(afm->Descender == 0.0)
-        afm->Descender = afm->FontBBox.lly;
-    if(afm->FullAscender == 0.0)
-        afm->FullAscender = afm->Ascender;
-    if(afm->Weight == 0)
-        afm->Weight = FW_NORMAL;
-
-    return afm;
-}
 
 /***********************************************************
  *
@@ -298,7 +63,7 @@ void PSDRV_FreeAFMList( FONTFAMILY *head )
  * Returns ptr to an AFM if name (which is a PS font name) exists in list
  * headed by head.
  */
-AFM *PSDRV_FindAFMinList(FONTFAMILY *head, char *name)
+const AFM *PSDRV_FindAFMinList(FONTFAMILY *head, LPCSTR name)
 {
     FONTFAMILY *family;
     AFMLISTENTRY *afmle;
@@ -316,10 +81,13 @@ AFM *PSDRV_FindAFMinList(FONTFAMILY *head, char *name)
  *
  *     PSDRV_AddAFMtoList
  *
- * Adds an afm to the list whose head is pointed to by head. Creates new
- * family node if necessary and always creates a new AFMLISTENTRY.
+ *  Adds an afm to the list whose head is pointed to by head. Creates new
+ *  family node if necessary and always creates a new AFMLISTENTRY.
+ *
+ *  Returns FALSE for memory allocation error; returns TRUE, but sets *p_added
+ *  to FALSE, for duplicate.
  */
-void PSDRV_AddAFMtoList(FONTFAMILY **head, AFM *afm)
+BOOL PSDRV_AddAFMtoList(FONTFAMILY **head, const AFM *afm, BOOL *p_added)
 {
     FONTFAMILY *family = *head;
     FONTFAMILY **insert = head;
@@ -327,6 +95,9 @@ void PSDRV_AddAFMtoList(FONTFAMILY **head, AFM *afm)
 
     newafmle = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY,
                           sizeof(*newafmle));
+    if (newafmle == NULL)
+       return FALSE;
+
     newafmle->afm = afm;
 
     while(family) {
@@ -335,78 +106,166 @@ void PSDRV_AddAFMtoList(FONTFAMILY **head, AFM *afm)
        insert = &(family->next);
        family = family->next;
     }
+
     if(!family) {
         family = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY,
                           sizeof(*family));
+       if (family == NULL) {
+           HeapFree(PSDRV_Heap, 0, newafmle);
+           return FALSE;
+       }
        *insert = family;
-       family->FamilyName = HEAP_strdupA(PSDRV_Heap, 0,
-                                         afm->FamilyName);
+       if (!(family->FamilyName = HeapAlloc(PSDRV_Heap, 0, strlen(afm->FamilyName)+1 ))) {
+           HeapFree(PSDRV_Heap, 0, family);
+           HeapFree(PSDRV_Heap, 0, newafmle);
+           return FALSE;
+       }
+       strcpy( family->FamilyName, afm->FamilyName );
        family->afmlist = newafmle;
-       return;
+       *p_added = TRUE;
+       return TRUE;
+    }
+    else {
+       tmpafmle = family->afmlist;
+       while (tmpafmle) {
+           if (!strcmp(tmpafmle->afm->FontName, afm->FontName)) {
+               WARN("Ignoring duplicate FontName '%s'\n", afm->FontName);
+               HeapFree(PSDRV_Heap, 0, newafmle);
+               *p_added = FALSE;
+               return TRUE;                        /* not a fatal error */
+           }
+           tmpafmle = tmpafmle->next;
+       }
     }
-    
+
     tmpafmle = family->afmlist;
     while(tmpafmle->next)
         tmpafmle = tmpafmle->next;
 
     tmpafmle->next = newafmle;
 
-    return;
+    *p_added = TRUE;
+    return TRUE;
 }
 
-/**********************************************************
- *
- *     PSDRV_ReencodeCharWidths
+
+/***********************************************************
  *
- * Re map the CharWidths field of the afm to correspond to an ANSI encoding
+ *     PSDRV_DumpFontList
  *
  */
-static void PSDRV_ReencodeCharWidths(AFM *afm)
+static void PSDRV_DumpFontList(void)
 {
-    int i, j;
-    AFMMETRICS *metric;
-
-    for(i = 0; i < 256; i++) {
-        if(isalnum(i))
-           continue;
-       if(PSDRV_ANSIVector[i] == NULL) {
-           afm->CharWidths[i] = 0.0;
-           continue;
-       }
-        for (j = 0, metric = afm->Metrics; j < afm->NumofMetrics; j++, metric++) {
-           if(!strcmp(metric->N, PSDRV_ANSIVector[i])) {
-               afm->CharWidths[i] = metric->WX;
-               break;
+    FONTFAMILY      *family;
+    AFMLISTENTRY    *afmle;
+
+    for(family = PSDRV_AFMFontList; family; family = family->next) {
+        TRACE("Family '%s'\n", family->FamilyName);
+       for(afmle = family->afmlist; afmle; afmle = afmle->next)
+       {
+#if 0
+           INT i;
+#endif
+
+           TRACE("\tFontName '%s' (%i glyphs) - '%s' encoding:\n",
+                   afmle->afm->FontName, afmle->afm->NumofMetrics,
+                   afmle->afm->EncodingScheme);
+
+           /* Uncomment to regenerate font data; see afm2c.c */
+
+           /* PSDRV_AFM2C(afmle->afm); */
+
+#if 0
+           for (i = 0; i < afmle->afm->NumofMetrics; ++i)
+           {
+               TRACE("\t\tU+%.4lX; C %i; N '%s'\n", afmle->afm->Metrics[i].UV,
+                       afmle->afm->Metrics[i].C, afmle->afm->Metrics[i].N->sz);
            }
-       }
-       if(j == afm->NumofMetrics) {
-           WARN("Couldn't find glyph '%s' in font '%s'\n",
-                PSDRV_ANSIVector[i], afm->FontName);
-           afm->CharWidths[i] = 0.0;
+#endif
        }
     }
     return;
 }
 
 
-/***********************************************************
+/*******************************************************************************
+ *  PSDRV_CalcAvgCharWidth
  *
- *     PSDRV_DumpFontList
+ *  Calculate WinMetrics.sAvgCharWidth for a Type 1 font.  Can also be used on
+ *  TrueType fonts, if font designer set OS/2:xAvgCharWidth to zero.
  *
+ *  Tries to use formula in TrueType specification; falls back to simple mean
+ *  if any lowercase latin letter (or space) is not present.
  */
-static void PSDRV_DumpFontList(void)
+inline static SHORT MeanCharWidth(const AFM *afm)
 {
-    FONTFAMILY *family;
-    AFMLISTENTRY *afmle;
+    float   w = 0.0;
+    int     i;
 
-    for(family = PSDRV_AFMFontList; family; family = family->next) {
-        TRACE("Family '%s'\n", family->FamilyName);
-       for(afmle = family->afmlist; afmle; afmle = afmle->next) {
-           TRACE("\tFontName '%s'\n", afmle->afm->FontName);
-       }
+    for (i = 0; i < afm->NumofMetrics; ++i)
+       w += afm->Metrics[i].WX;
+
+    w /= afm->NumofMetrics;
+
+    return (SHORT)(w + 0.5);
+}
+
+static const struct { LONG UV; int weight; } UVweight[27] =
+{
+    { 0x0061,  64 }, { 0x0062,  14 }, { 0x0063,  27 }, { 0x0064,  35 },
+    { 0x0065, 100 }, { 0x0066,  20 }, { 0x0067,  14 }, { 0x0068,  42 },
+    { 0x0069,  63 }, { 0x006a,   3 }, { 0x006b,   6 }, { 0x006c,  35 },
+    { 0x006d,  20 }, { 0x006e,  56 }, { 0x006f,  56 }, { 0x0070,  17 },
+    { 0x0071,   4 }, { 0x0072,  49 }, { 0x0073,  56 }, { 0x0074,  71 },
+    { 0x0075,  31 }, { 0x0076,  10 }, { 0x0077,  18 }, { 0x0078,   3 },
+    { 0x0079,  18 }, { 0x007a,   2 }, { 0x0020, 166 }
+};
+
+SHORT PSDRV_CalcAvgCharWidth(const AFM *afm)
+{
+    float   w = 0.0;
+    int     i;
+
+    for (i = 0; i < 27; ++i)
+    {
+       const AFMMETRICS    *afmm;
+
+       afmm = PSDRV_UVMetrics(UVweight[i].UV, afm);
+       if (afmm->UV != UVweight[i].UV)     /* UVMetrics returns first glyph */
+           return MeanCharWidth(afm);      /*   in font if UV is missing    */
+
+       w += afmm->WX * (float)(UVweight[i].weight);
     }
-    return;
+
+    w /= 1000.0;
+
+    return (SHORT)(w + 0.5);
+}
+
+
+/*******************************************************************************
+ *  AddBuiltinAFMs
+ *
+ */
+
+static BOOL AddBuiltinAFMs()
+{
+    const AFM *const   *afm = PSDRV_BuiltinAFMs;
+
+    while (*afm != NULL)
+    {
+       BOOL    added;
+
+       if (PSDRV_AddAFMtoList(&PSDRV_AFMFontList, *afm, &added) == FALSE)
+           return FALSE;
+
+       if (added == FALSE)
+           TRACE("Ignoring built-in font %s\n", (*afm)->FontName);
+
+       ++afm;
+    }
+
+    return TRUE;
 }
 
 
@@ -414,28 +273,33 @@ static void PSDRV_DumpFontList(void)
  *
  *     PSDRV_GetFontMetrics
  *
- * Only exported function in this file. Parses all afm files listed in
- * [afmfiles] of wine.conf .
+ * Parses all afm files listed in [afmdirs] and [TrueType Font Directories]
+ * sections of Wine configuration file.  Adds built-in data last, so it can
+ * be overridden by user-supplied AFM or TTF files.
+ *
+ * If this function fails, PSDRV_Init will destroy PSDRV_Heap, so don't worry
+ * about freeing all the memory that's been allocated.
  */
+
 BOOL PSDRV_GetFontMetrics(void)
 {
-    int idx = 0;
-    char key[256];
-    char value[256];
+    if (PSDRV_GlyphListInit() != 0)
+       return FALSE;
+
+    if (PSDRV_GetType1Metrics() == FALSE)
+       return FALSE;
+
+#ifdef HAVE_FREETYPE
+    if (PSDRV_GetTrueTypeMetrics() == FALSE)
+       return FALSE;
+#endif
+
+    if (AddBuiltinAFMs() == FALSE)
+       return FALSE;
+
+    PSDRV_IndexGlyphList();        /* Enable fast searching of glyph names */
 
-    while (PROFILE_EnumWineIniString( "afmfiles", idx++, key, sizeof(key), value, sizeof(value)))
-    {
-        AFM *afm = PSDRV_AFMParse(value);
-        if (afm)
-        {
-            if(afm->EncodingScheme && 
-               !strcmp(afm->EncodingScheme, "AdobeStandardEncoding")) {
-                PSDRV_ReencodeCharWidths(afm);
-            }
-            PSDRV_AddAFMtoList(&PSDRV_AFMFontList, afm);
-        }
-    }
     PSDRV_DumpFontList();
+
     return TRUE;
 }
-