git.oblomov.eu Git - wine/blob - dlls/wineps.drv/builtin.c

   1 /*
   2  *      PostScript driver builtin font functions
   3  *
   4  *      Copyright 2002  Huw D M Davies for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdarg.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <math.h>
  24 #include <assert.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "wingdi.h"
  30
  31 #include "psdrv.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  35
  36
  37 /***********************************************************************
  38  *           is_stock_font
  39  */
  40 static inline BOOL is_stock_font( HFONT font )
  41 {
  42     int i;
  43     for (i = OEM_FIXED_FONT; i <= DEFAULT_GUI_FONT; i++)
  44     {
  45         if (i != DEFAULT_PALETTE && font == GetStockObject(i)) return TRUE;
  46     }
  47     return FALSE;
  48 }
  49
  50
  51 /*******************************************************************************
  52  *  ScaleFont
  53  *
  54  *  Scale builtin font to requested lfHeight
  55  *
  56  */
  57 static inline float Round(float f)
  58 {
  59     return (f > 0) ? (f + 0.5) : (f - 0.5);
  60 }
  61
  62 static VOID ScaleFont(const AFM *afm, LONG lfHeight, PSFONT *font,
  63                       TEXTMETRICW *tm)
  64 {
  65     const WINMETRICS    *wm = &(afm->WinMetrics);
  66     USHORT              usUnitsPerEm, usWinAscent, usWinDescent;
  67     SHORT               sAscender, sDescender, sLineGap, sAvgCharWidth;
  68
  69     TRACE("'%s' %i\n", afm->FontName, lfHeight);
  70
  71     if (lfHeight < 0)                                   /* match em height */
  72     {
  73         font->fontinfo.Builtin.scale = - ((float)lfHeight / (float)(wm->usUnitsPerEm));
  74     }
  75     else                                                /* match cell height */
  76     {
  77         font->fontinfo.Builtin.scale = (float)lfHeight /
  78                 (float)(wm->usWinAscent + wm->usWinDescent);
  79     }
  80
  81     font->size = (INT)Round(font->fontinfo.Builtin.scale * (float)wm->usUnitsPerEm);
  82
  83     usUnitsPerEm = (USHORT)Round((float)(wm->usUnitsPerEm) * font->fontinfo.Builtin.scale);
  84     sAscender = (SHORT)Round((float)(wm->sAscender) * font->fontinfo.Builtin.scale);
  85     sDescender = (SHORT)Round((float)(wm->sDescender) * font->fontinfo.Builtin.scale);
  86     sLineGap = (SHORT)Round((float)(wm->sLineGap) * font->fontinfo.Builtin.scale);
  87     usWinAscent = (USHORT)Round((float)(wm->usWinAscent) * font->fontinfo.Builtin.scale);
  88     usWinDescent = (USHORT)Round((float)(wm->usWinDescent) * font->fontinfo.Builtin.scale);
  89     sAvgCharWidth = (SHORT)Round((float)(wm->sAvgCharWidth) * font->fontinfo.Builtin.scale);
  90
  91     tm->tmAscent = (LONG)usWinAscent;
  92     tm->tmDescent = (LONG)usWinDescent;
  93     tm->tmHeight = tm->tmAscent + tm->tmDescent;
  94
  95     tm->tmInternalLeading = tm->tmHeight - (LONG)usUnitsPerEm;
  96     if (tm->tmInternalLeading < 0)
  97         tm->tmInternalLeading = 0;
  98
  99     tm->tmExternalLeading =
 100             (LONG)(sAscender - sDescender + sLineGap) - tm->tmHeight;
 101     if (tm->tmExternalLeading < 0)
 102         tm->tmExternalLeading = 0;
 103
 104     tm->tmAveCharWidth = (LONG)sAvgCharWidth;
 105
 106     tm->tmWeight = afm->Weight;
 107     tm->tmItalic = (afm->ItalicAngle != 0.0);
 108     tm->tmUnderlined = 0;
 109     tm->tmStruckOut = 0;
 110     tm->tmFirstChar = (WCHAR)(afm->Metrics[0].UV);
 111     tm->tmLastChar = (WCHAR)(afm->Metrics[afm->NumofMetrics - 1].UV);
 112     tm->tmDefaultChar = 0x001f;         /* Win2K does this - FIXME? */
 113     tm->tmBreakChar = tm->tmFirstChar;          /* should be 'space' */
 114
 115     tm->tmPitchAndFamily = TMPF_DEVICE | TMPF_VECTOR;
 116     if (!afm->IsFixedPitch)
 117         tm->tmPitchAndFamily |= TMPF_FIXED_PITCH;   /* yes, it's backwards */
 118     if (wm->usUnitsPerEm != 1000)
 119         tm->tmPitchAndFamily |= TMPF_TRUETYPE;
 120
 121     tm->tmCharSet = ANSI_CHARSET;       /* FIXME */
 122     tm->tmOverhang = 0;
 123
 124     /*
 125      *  This is kludgy.  font->scale is used in several places in the driver
 126      *  to adjust PostScript-style metrics.  Since these metrics have been
 127      *  "normalized" to an em-square size of 1000, font->scale needs to be
 128      *  similarly adjusted..
 129      */
 130
 131     font->fontinfo.Builtin.scale *= (float)wm->usUnitsPerEm / 1000.0;
 132
 133     tm->tmMaxCharWidth = (LONG)Round(
 134             (afm->FontBBox.urx - afm->FontBBox.llx) * font->fontinfo.Builtin.scale);
 135
 136     font->underlinePosition = afm->UnderlinePosition * font->fontinfo.Builtin.scale;
 137     font->underlineThickness = afm->UnderlineThickness * font->fontinfo.Builtin.scale;
 138     font->strikeoutPosition = tm->tmAscent / 2;
 139     font->strikeoutThickness = font->underlineThickness;
 140
 141     TRACE("Selected PS font '%s' size %d weight %d.\n", afm->FontName,
 142             font->size, tm->tmWeight );
 143     TRACE("H = %d As = %d Des = %d IL = %d EL = %d\n", tm->tmHeight,
 144             tm->tmAscent, tm->tmDescent, tm->tmInternalLeading,
 145             tm->tmExternalLeading);
 146 }
 147
 148
 149 /****************************************************************************
 150  *  PSDRV_SelectBuiltinFont
 151  *
 152  *  Set up physDev->font for a builtin font
 153  *
 154  */
 155 BOOL PSDRV_SelectBuiltinFont(PSDRV_PDEVICE *physDev, HFONT hfont,
 156                              LOGFONTW *plf, LPSTR FaceName)
 157 {
 158     AFMLISTENTRY *afmle;
 159     FONTFAMILY *family;
 160     BOOL bd = FALSE, it = FALSE;
 161     LONG height;
 162
 163     TRACE("Trying to find facename '%s'\n", FaceName);
 164
 165     /* Look for a matching font family */
 166     for(family = physDev->pi->Fonts; family; family = family->next) {
 167         if(!strcasecmp(FaceName, family->FamilyName))
 168             break;
 169     }
 170
 171     if(!family) {
 172         /* Fallback for Window's font families to common PostScript families */
 173         if(!strcmp(FaceName, "Arial"))
 174             strcpy(FaceName, "Helvetica");
 175         else if(!strcmp(FaceName, "System"))
 176             strcpy(FaceName, "Helvetica");
 177         else if(!strcmp(FaceName, "Times New Roman"))
 178             strcpy(FaceName, "Times");
 179         else if(!strcmp(FaceName, "Courier New"))
 180             strcpy(FaceName, "Courier");
 181
 182         for(family = physDev->pi->Fonts; family; family = family->next) {
 183             if(!strcmp(FaceName, family->FamilyName))
 184                 break;
 185         }
 186     }
 187     /* If all else fails, use the first font defined for the printer */
 188     if(!family)
 189         family = physDev->pi->Fonts;
 190
 191     TRACE("Got family '%s'\n", family->FamilyName);
 192
 193     if(plf->lfItalic)
 194         it = TRUE;
 195     if(plf->lfWeight > 550)
 196         bd = TRUE;
 197
 198     for(afmle = family->afmlist; afmle; afmle = afmle->next) {
 199         if( (bd == (afmle->afm->Weight == FW_BOLD)) &&
 200             (it == (afmle->afm->ItalicAngle != 0.0)) )
 201                 break;
 202     }
 203     if(!afmle)
 204         afmle = family->afmlist; /* not ideal */
 205
 206     TRACE("Got font '%s'\n", afmle->afm->FontName);
 207
 208     physDev->font.fontloc = Builtin;
 209     physDev->font.fontinfo.Builtin.afm = afmle->afm;
 210
 211     height = plf->lfHeight;
 212     /* stock fonts ignore the mapping mode */
 213     if (!is_stock_font( hfont )) {
 214         POINT pts[2];
 215         pts[0].x = pts[0].y = pts[1].x = 0;
 216         pts[1].y = height;
 217         LPtoDP(physDev->hdc, pts, 2);
 218         height = pts[1].y - pts[0].y;
 219     }
 220     ScaleFont(physDev->font.fontinfo.Builtin.afm, height,
 221               &(physDev->font), &(physDev->font.fontinfo.Builtin.tm));
 222
 223
 224     /* Does anyone know if these are supposed to be reversed like this? */
 225
 226     physDev->font.fontinfo.Builtin.tm.tmDigitizedAspectX = physDev->logPixelsY;
 227     physDev->font.fontinfo.Builtin.tm.tmDigitizedAspectY = physDev->logPixelsX;
 228
 229     return TRUE;
 230 }
 231
 232 BOOL PSDRV_WriteSetBuiltinFont(PSDRV_PDEVICE *physDev)
 233 {
 234     return PSDRV_WriteSetFont(physDev,
 235                               physDev->font.fontinfo.Builtin.afm->FontName,
 236                               physDev->font.size, physDev->font.escapement);
 237 }
 238
 239 BOOL PSDRV_WriteBuiltinGlyphShow(PSDRV_PDEVICE *physDev, LPCWSTR str, INT count)
 240 {
 241     int i;
 242     LPCSTR name;
 243
 244     for (i = 0; i < count; ++i)
 245     {
 246         name = PSDRV_UVMetrics(str[i], physDev->font.fontinfo.Builtin.afm)->N->sz;
 247
 248         PSDRV_WriteGlyphShow(physDev, name);
 249     }
 250
 251     return TRUE;
 252 }
 253
 254 /***********************************************************************
 255  *           PSDRV_GetTextMetrics
 256  */
 257 BOOL PSDRV_GetTextMetrics(PSDRV_PDEVICE *physDev, TEXTMETRICW *metrics)
 258 {
 259     assert(physDev->font.fontloc == Builtin);
 260
 261     memcpy(metrics, &(physDev->font.fontinfo.Builtin.tm),
 262            sizeof(physDev->font.fontinfo.Builtin.tm));
 263     return TRUE;
 264 }
 265
 266 /******************************************************************************
 267  *      PSDRV_UVMetrics
 268  *
 269  *  Find the AFMMETRICS for a given UV.  Returns first glyph in the font
 270  *  (space?) if the font does not have a glyph for the given UV.
 271  */
 272 static int MetricsByUV(const void *a, const void *b)
 273 {
 274     return (int)(((const AFMMETRICS *)a)->UV - ((const AFMMETRICS *)b)->UV);
 275 }
 276
 277 const AFMMETRICS *PSDRV_UVMetrics(LONG UV, const AFM *afm)
 278 {
 279     AFMMETRICS          key;
 280     const AFMMETRICS    *needle;
 281
 282     /*
 283      *  Ugly work-around for symbol fonts.  Wine is sending characters which
 284      *  belong in the Unicode private use range (U+F020 - U+F0FF) as ASCII
 285      *  characters (U+0020 - U+00FF).
 286      */
 287
 288     if ((afm->Metrics->UV & 0xff00) == 0xf000 && UV < 0x100)
 289         UV |= 0xf000;
 290
 291     key.UV = UV;
 292
 293     needle = bsearch(&key, afm->Metrics, afm->NumofMetrics, sizeof(AFMMETRICS),
 294             MetricsByUV);
 295
 296     if (needle == NULL)
 297     {
 298         WARN("No glyph for U+%.4X in %s\n", UV, afm->FontName);
 299         needle = afm->Metrics;
 300     }
 301
 302     return needle;
 303 }
 304
 305 /***********************************************************************
 306  *           PSDRV_GetTextExtentExPoint
 307  */
 308 BOOL PSDRV_GetTextExtentExPoint(PSDRV_PDEVICE *physDev, LPCWSTR str, INT count,
 309                                 INT maxExt, LPINT lpnFit, LPINT alpDx, LPSIZE size)
 310 {
 311     int             nfit = 0;
 312     int             i;
 313     float           width = 0.0;
 314     float           scale;
 315
 316     assert(physDev->font.fontloc == Builtin);
 317
 318     TRACE("%s %i\n", debugstr_wn(str, count), count);
 319
 320     scale = physDev->font.fontinfo.Builtin.scale;
 321     for (i = 0; i < count && str[i] != '\0'; ++i)
 322     {
 323         float scaled_width;
 324         width += PSDRV_UVMetrics(str[i], physDev->font.fontinfo.Builtin.afm)->WX;
 325         scaled_width = width * scale;
 326         if (alpDx)
 327             alpDx[i] = scaled_width;
 328         if (scaled_width <= maxExt)
 329             ++nfit;
 330     }
 331
 332     size->cx = width * physDev->font.fontinfo.Builtin.scale;
 333     size->cy = physDev->font.fontinfo.Builtin.tm.tmHeight;
 334
 335     if (lpnFit)
 336         *lpnFit = nfit;
 337
 338     TRACE("cx=%i cy=%i\n", size->cx, size->cy);
 339
 340     return TRUE;
 341 }
 342
 343 /***********************************************************************
 344  *           PSDRV_GetCharWidth
 345  */
 346 BOOL PSDRV_GetCharWidth(PSDRV_PDEVICE *physDev, UINT firstChar, UINT lastChar, LPINT buffer)
 347 {
 348     UINT            i;
 349
 350     assert(physDev->font.fontloc == Builtin);
 351
 352     TRACE("U+%.4X U+%.4X\n", firstChar, lastChar);
 353
 354     if (lastChar > 0xffff || firstChar > lastChar)
 355     {
 356         SetLastError(ERROR_INVALID_PARAMETER);
 357         return FALSE;
 358     }
 359
 360     for (i = firstChar; i <= lastChar; ++i)
 361     {
 362         *buffer = floor( PSDRV_UVMetrics(i, physDev->font.fontinfo.Builtin.afm)->WX
 363                          * physDev->font.fontinfo.Builtin.scale + 0.5 );
 364         TRACE("U+%.4X: %i\n", i, *buffer);
 365         ++buffer;
 366     }
 367
 368     return TRUE;
 369 }
 370
 371
 372 /***********************************************************************
 373  *           PSDRV_GetFontMetric
 374  */
 375 static UINT PSDRV_GetFontMetric(HDC hdc, const AFM *afm,
 376         NEWTEXTMETRICEXW *ntmx, ENUMLOGFONTEXW *elfx)
 377 {
 378     /* ntmx->ntmTm is NEWTEXTMETRICW; compatible w/ TEXTMETRICW per Win32 doc */
 379
 380     TEXTMETRICW     *tm = (TEXTMETRICW *)&(ntmx->ntmTm);
 381     LOGFONTW        *lf = &(elfx->elfLogFont);
 382     PSFONT          font;
 383
 384     memset(ntmx, 0, sizeof(*ntmx));
 385     memset(elfx, 0, sizeof(*elfx));
 386
 387     ScaleFont(afm, -(LONG)(afm->WinMetrics.usUnitsPerEm), &font, tm);
 388
 389     lf->lfHeight = tm->tmHeight;
 390     lf->lfWidth = tm->tmAveCharWidth;
 391     lf->lfWeight = tm->tmWeight;
 392     lf->lfItalic = tm->tmItalic;
 393     lf->lfCharSet = tm->tmCharSet;
 394
 395     lf->lfPitchAndFamily = (afm->IsFixedPitch) ? FIXED_PITCH : VARIABLE_PITCH;
 396
 397     MultiByteToWideChar(CP_ACP, 0, afm->FamilyName, -1, lf->lfFaceName,
 398             LF_FACESIZE);
 399
 400     return DEVICE_FONTTYPE;
 401 }
 402
 403 /***********************************************************************
 404  *           PSDRV_EnumDeviceFonts
 405  */
 406 BOOL PSDRV_EnumDeviceFonts( PSDRV_PDEVICE *physDev, LPLOGFONTW plf,
 407                             FONTENUMPROCW proc, LPARAM lp )
 408 {
 409     ENUMLOGFONTEXW      lf;
 410     NEWTEXTMETRICEXW    tm;
 411     BOOL                b, bRet = 0;
 412     AFMLISTENTRY        *afmle;
 413     FONTFAMILY          *family;
 414     char                FaceName[LF_FACESIZE];
 415
 416     if( plf && plf->lfFaceName[0] ) {
 417         WideCharToMultiByte(CP_ACP, 0, plf->lfFaceName, -1,
 418                           FaceName, sizeof(FaceName), NULL, NULL);
 419         TRACE("lfFaceName = '%s'\n", FaceName);
 420         for(family = physDev->pi->Fonts; family; family = family->next) {
 421             if(!strncmp(FaceName, family->FamilyName,
 422                         strlen(family->FamilyName)))
 423                 break;
 424         }
 425         if(family) {
 426             for(afmle = family->afmlist; afmle; afmle = afmle->next) {
 427                 TRACE("Got '%s'\n", afmle->afm->FontName);
 428                 if( (b = (*proc)( &lf.elfLogFont, (TEXTMETRICW *)&tm,
 429                         PSDRV_GetFontMetric( physDev->hdc, afmle->afm, &tm, &lf ),
 430                                   lp )) )
 431                      bRet = b;
 432                 else break;
 433             }
 434         }
 435     } else {
 436
 437         TRACE("lfFaceName = NULL\n");
 438         for(family = physDev->pi->Fonts; family; family = family->next) {
 439             afmle = family->afmlist;
 440             TRACE("Got '%s'\n", afmle->afm->FontName);
 441             if( (b = (*proc)( &lf.elfLogFont, (TEXTMETRICW *)&tm,
 442                    PSDRV_GetFontMetric( physDev->hdc, afmle->afm, &tm, &lf ),
 443                               lp )) )
 444                 bRet = b;
 445             else break;
 446         }
 447     }
 448     return bRet;
 449 }