juce/source/src/native/linux/juce_linux_Fonts.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 // (This file gets included by juce_linux_NativeCode.cpp, rather than being
  27 // compiled on its own).
  28 #if JUCE_INCLUDED_FILE
  29
  30
  31 //==============================================================================
  32 class FreeTypeFontFace
  33 {
  34 public:
  35     //==============================================================================
  36     enum FontStyle
  37     {
  38         Plain = 0,
  39         Bold = 1,
  40         Italic = 2
  41     };
  42
  43     //==============================================================================
  44     FreeTypeFontFace (const String& familyName)
  45       : hasSerif (false),
  46         monospaced (false)
  47     {
  48         family = familyName;
  49     }
  50
  51     void setFileName (const String& name, const int faceIndex, FontStyle style)
  52     {
  53         if (names [(int) style].fileName.isEmpty())
  54         {
  55             names [(int) style].fileName = name;
  56             names [(int) style].faceIndex = faceIndex;
  57         }
  58     }
  59
  60     const String& getFamilyName() const noexcept    { return family; }
  61
  62     const String& getFileName (const int style, int& faceIndex) const noexcept
  63     {
  64         faceIndex = names[style].faceIndex;
  65         return names[style].fileName;
  66     }
  67
  68     void setMonospaced (bool mono) noexcept     { monospaced = mono; }
  69     bool getMonospaced() const noexcept         { return monospaced; }
  70
  71     void setSerif (const bool serif) noexcept   { hasSerif = serif; }
  72     bool getSerif() const noexcept              { return hasSerif; }
  73
  74 private:
  75     //==============================================================================
  76     String family;
  77
  78     struct FontNameIndex
  79     {
  80         String fileName;
  81         int faceIndex;
  82     };
  83
  84     FontNameIndex names[4];
  85     bool hasSerif, monospaced;
  86 };
  87
  88 //==============================================================================
  89 class LinuxFontFileIterator
  90 {
  91 public:
  92     LinuxFontFileIterator()
  93         : index (0)
  94     {
  95         fontDirs.addTokens (CharPointer_UTF8 (getenv ("JUCE_FONT_PATH")), ";,", String::empty);
  96         fontDirs.removeEmptyStrings (true);
  97
  98         if (fontDirs.size() == 0)
  99         {
 100             const ScopedPointer<XmlElement> fontsInfo (XmlDocument::parse (File ("/etc/fonts/fonts.conf")));
 101
 102             if (fontsInfo != nullptr)
 103             {
 104                 forEachXmlChildElementWithTagName (*fontsInfo, e, "dir")
 105                 {
 106                     fontDirs.add (e->getAllSubText().trim());
 107                 }
 108             }
 109         }
 110
 111         if (fontDirs.size() == 0)
 112             fontDirs.add ("/usr/X11R6/lib/X11/fonts");
 113
 114         fontDirs.removeEmptyStrings (true);
 115     }
 116
 117     bool next()
 118     {
 119         if (iter != nullptr)
 120         {
 121             while (iter->next())
 122                 if (getFile().hasFileExtension ("ttf;pfb;pcf"))
 123                     return true;
 124         }
 125
 126         if (index >= fontDirs.size())
 127             return false;
 128
 129         iter = new DirectoryIterator (fontDirs [index++], true);
 130         return next();
 131     }
 132
 133     File getFile() const    { jassert (iter != nullptr); return iter->getFile(); }
 134
 135 private:
 136     StringArray fontDirs;
 137     int index;
 138     ScopedPointer<DirectoryIterator> iter;
 139 };
 140
 141
 142 //==============================================================================
 143 class FreeTypeInterface  : public DeletedAtShutdown
 144 {
 145 public:
 146     //==============================================================================
 147     FreeTypeInterface()
 148         : ftLib (0),
 149           lastFace (0),
 150           lastBold (false),
 151           lastItalic (false)
 152     {
 153         if (FT_Init_FreeType (&ftLib) != 0)
 154         {
 155             ftLib = 0;
 156             DBG ("Failed to initialize FreeType");
 157         }
 158
 159         LinuxFontFileIterator fontFileIterator;
 160
 161         while (fontFileIterator.next())
 162         {
 163             FT_Face face;
 164             int faceIndex = 0;
 165             int numFaces = 0;
 166
 167             do
 168             {
 169                 if (FT_New_Face (ftLib, fontFileIterator.getFile().getFullPathName().toUTF8(),
 170                                  faceIndex, &face) == 0)
 171                 {
 172                     if (faceIndex == 0)
 173                         numFaces = face->num_faces;
 174
 175                     if ((face->face_flags & FT_FACE_FLAG_SCALABLE) != 0)
 176                     {
 177                         FreeTypeFontFace* const newFace = findOrCreate (face->family_name, true);
 178                         int style = (int) FreeTypeFontFace::Plain;
 179
 180                         if ((face->style_flags & FT_STYLE_FLAG_BOLD) != 0)
 181                             style |= (int) FreeTypeFontFace::Bold;
 182
 183                         if ((face->style_flags & FT_STYLE_FLAG_ITALIC) != 0)
 184                             style |= (int) FreeTypeFontFace::Italic;
 185
 186                         newFace->setFileName (fontFileIterator.getFile().getFullPathName(),
 187                                               faceIndex, (FreeTypeFontFace::FontStyle) style);
 188                         newFace->setMonospaced ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0);
 189
 190                         // Surely there must be a better way to do this?
 191                         const String name (face->family_name);
 192                         newFace->setSerif (! (name.containsIgnoreCase ("Sans")
 193                                                || name.containsIgnoreCase ("Verdana")
 194                                                || name.containsIgnoreCase ("Arial")));
 195
 196                         //DBG (fontFileIterator.getFile().getFullPathName() << "  -  " << name);
 197                     }
 198
 199                     FT_Done_Face (face);
 200                 }
 201
 202                 ++faceIndex;
 203             }
 204             while (faceIndex < numFaces);
 205         }
 206     }
 207
 208     ~FreeTypeInterface()
 209     {
 210         if (lastFace != 0)
 211             FT_Done_Face (lastFace);
 212
 213         if (ftLib != 0)
 214             FT_Done_FreeType (ftLib);
 215
 216         clearSingletonInstance();
 217     }
 218
 219     //==============================================================================
 220     FreeTypeFontFace* findOrCreate (const String& familyName, const bool create = false)
 221     {
 222         for (int i = 0; i < faces.size(); i++)
 223             if (faces[i]->getFamilyName() == familyName)
 224                 return faces[i];
 225
 226         if (! create)
 227             return nullptr;
 228
 229         FreeTypeFontFace* newFace = new FreeTypeFontFace (familyName);
 230         faces.add (newFace);
 231
 232         return newFace;
 233     }
 234
 235     // Create a FreeType face object for a given font
 236     FT_Face createFT_Face (const String& fontName, const bool bold, const bool italic)
 237     {
 238         FT_Face face = 0;
 239
 240         if (fontName == lastFontName && bold == lastBold && italic == lastItalic)
 241         {
 242             face = lastFace;
 243         }
 244         else
 245         {
 246             if (lastFace != 0)
 247             {
 248                 FT_Done_Face (lastFace);
 249                 lastFace = 0;
 250             }
 251
 252             lastFontName = fontName;
 253             lastBold = bold;
 254             lastItalic = italic;
 255
 256             FreeTypeFontFace* const ftFace = findOrCreate (fontName);
 257
 258             if (ftFace != 0)
 259             {
 260                 int style = (int) FreeTypeFontFace::Plain;
 261
 262                 if (bold)
 263                     style |= (int) FreeTypeFontFace::Bold;
 264
 265                 if (italic)
 266                     style |= (int) FreeTypeFontFace::Italic;
 267
 268                 int faceIndex;
 269                 String fileName (ftFace->getFileName (style, faceIndex));
 270
 271                 if (fileName.isEmpty())
 272                 {
 273                     style ^= (int) FreeTypeFontFace::Bold;
 274
 275                     fileName = ftFace->getFileName (style, faceIndex);
 276
 277                     if (fileName.isEmpty())
 278                     {
 279                         style ^= (int) FreeTypeFontFace::Bold;
 280                         style ^= (int) FreeTypeFontFace::Italic;
 281
 282                         fileName = ftFace->getFileName (style, faceIndex);
 283
 284                         if (! fileName.length())
 285                         {
 286                             style ^= (int) FreeTypeFontFace::Bold;
 287                             fileName = ftFace->getFileName (style, faceIndex);
 288                         }
 289                     }
 290                 }
 291
 292                 if (! FT_New_Face (ftLib, fileName.toUTF8(), faceIndex, &lastFace))
 293                 {
 294                     face = lastFace;
 295
 296                     // If there isn't a unicode charmap then select the first one.
 297                     if (FT_Select_Charmap (face, ft_encoding_unicode))
 298                         FT_Set_Charmap (face, face->charmaps[0]);
 299                 }
 300             }
 301         }
 302
 303         return face;
 304     }
 305
 306     bool addGlyph (FT_Face face, CustomTypeface& dest, uint32 character)
 307     {
 308         const unsigned int glyphIndex = FT_Get_Char_Index (face, character);
 309         const float height = (float) (face->ascender - face->descender);
 310         const float scaleX = 1.0f / height;
 311         const float scaleY = -1.0f / height;
 312         Path destShape;
 313
 314         if (FT_Load_Glyph (face, glyphIndex, FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM) != 0
 315              || face->glyph->format != ft_glyph_format_outline)
 316         {
 317             return false;
 318         }
 319
 320         const FT_Outline* const outline = &face->glyph->outline;
 321         const short* const contours = outline->contours;
 322         const char* const tags = outline->tags;
 323         FT_Vector* const points = outline->points;
 324
 325         for (int c = 0; c < outline->n_contours; c++)
 326         {
 327             const int startPoint = (c == 0) ? 0 : contours [c - 1] + 1;
 328             const int endPoint = contours[c];
 329
 330             for (int p = startPoint; p <= endPoint; p++)
 331             {
 332                 const float x = scaleX * points[p].x;
 333                 const float y = scaleY * points[p].y;
 334
 335                 if (p == startPoint)
 336                 {
 337                     if (FT_CURVE_TAG (tags[p]) == FT_Curve_Tag_Conic)
 338                     {
 339                         float x2 = scaleX * points [endPoint].x;
 340                         float y2 = scaleY * points [endPoint].y;
 341
 342                         if (FT_CURVE_TAG (tags[endPoint]) != FT_Curve_Tag_On)
 343                         {
 344                             x2 = (x + x2) * 0.5f;
 345                             y2 = (y + y2) * 0.5f;
 346                         }
 347
 348                         destShape.startNewSubPath (x2, y2);
 349                     }
 350                     else
 351                     {
 352                         destShape.startNewSubPath (x, y);
 353                     }
 354                 }
 355
 356                 if (FT_CURVE_TAG (tags[p]) == FT_Curve_Tag_On)
 357                 {
 358                     if (p != startPoint)
 359                         destShape.lineTo (x, y);
 360                 }
 361                 else if (FT_CURVE_TAG (tags[p]) == FT_Curve_Tag_Conic)
 362                 {
 363                     const int nextIndex = (p == endPoint) ? startPoint : p + 1;
 364                     float x2 = scaleX * points [nextIndex].x;
 365                     float y2 = scaleY * points [nextIndex].y;
 366
 367                     if (FT_CURVE_TAG (tags [nextIndex]) == FT_Curve_Tag_Conic)
 368                     {
 369                         x2 = (x + x2) * 0.5f;
 370                         y2 = (y + y2) * 0.5f;
 371                     }
 372                     else
 373                     {
 374                         ++p;
 375                     }
 376
 377                     destShape.quadraticTo (x, y, x2, y2);
 378                 }
 379                 else if (FT_CURVE_TAG (tags[p]) == FT_Curve_Tag_Cubic)
 380                 {
 381                     if (p >= endPoint)
 382                         return false;
 383
 384                     const int next1 = p + 1;
 385                     const int next2 = (p == (endPoint - 1)) ? startPoint : p + 2;
 386
 387                     const float x2 = scaleX * points [next1].x;
 388                     const float y2 = scaleY * points [next1].y;
 389                     const float x3 = scaleX * points [next2].x;
 390                     const float y3 = scaleY * points [next2].y;
 391
 392                     if (FT_CURVE_TAG (tags[next1]) != FT_Curve_Tag_Cubic
 393                          || FT_CURVE_TAG (tags[next2]) != FT_Curve_Tag_On)
 394                         return false;
 395
 396                     destShape.cubicTo (x, y, x2, y2, x3, y3);
 397                     p += 2;
 398                 }
 399             }
 400
 401             destShape.closeSubPath();
 402         }
 403
 404         dest.addGlyph (character, destShape, face->glyph->metrics.horiAdvance / height);
 405
 406         if ((face->face_flags & FT_FACE_FLAG_KERNING) != 0)
 407             addKerning (face, dest, character, glyphIndex);
 408
 409         return true;
 410     }
 411
 412     void addKerning (FT_Face face, CustomTypeface& dest, const uint32 character, const uint32 glyphIndex)
 413     {
 414         const float height = (float) (face->ascender - face->descender);
 415
 416         uint32 rightGlyphIndex;
 417         uint32 rightCharCode = FT_Get_First_Char (face, &rightGlyphIndex);
 418
 419         while (rightGlyphIndex != 0)
 420         {
 421             FT_Vector kerning;
 422
 423             if (FT_Get_Kerning (face, glyphIndex, rightGlyphIndex, ft_kerning_unscaled, &kerning) == 0)
 424             {
 425                 if (kerning.x != 0)
 426                     dest.addKerningPair (character, rightCharCode, kerning.x / height);
 427             }
 428
 429             rightCharCode = FT_Get_Next_Char (face, rightCharCode, &rightGlyphIndex);
 430         }
 431     }
 432
 433     // Add a glyph to a font
 434     bool addGlyphToFont (const uint32 character, const String& fontName,
 435                          bool bold, bool italic, CustomTypeface& dest)
 436     {
 437         FT_Face face = createFT_Face (fontName, bold, italic);
 438
 439         return face != 0 && addGlyph (face, dest, character);
 440     }
 441
 442     //==============================================================================
 443     void getFamilyNames (StringArray& familyNames) const
 444     {
 445         for (int i = 0; i < faces.size(); i++)
 446             familyNames.add (faces[i]->getFamilyName());
 447     }
 448
 449     void getMonospacedNames (StringArray& monoSpaced) const
 450     {
 451         for (int i = 0; i < faces.size(); i++)
 452             if (faces[i]->getMonospaced())
 453                 monoSpaced.add (faces[i]->getFamilyName());
 454     }
 455
 456     void getSerifNames (StringArray& serif) const
 457     {
 458         for (int i = 0; i < faces.size(); i++)
 459             if (faces[i]->getSerif())
 460                 serif.add (faces[i]->getFamilyName());
 461     }
 462
 463     void getSansSerifNames (StringArray& sansSerif) const
 464     {
 465         for (int i = 0; i < faces.size(); i++)
 466             if (! faces[i]->getSerif())
 467                 sansSerif.add (faces[i]->getFamilyName());
 468     }
 469
 470     juce_DeclareSingleton_SingleThreaded_Minimal (FreeTypeInterface);
 471
 472 private:
 473     //==============================================================================
 474     FT_Library ftLib;
 475     FT_Face lastFace;
 476     String lastFontName;
 477     bool lastBold, lastItalic;
 478     OwnedArray<FreeTypeFontFace> faces;
 479 };
 480
 481 juce_ImplementSingleton_SingleThreaded (FreeTypeInterface)
 482
 483
 484 //==============================================================================
 485 class FreetypeTypeface   : public CustomTypeface
 486 {
 487 public:
 488     FreetypeTypeface (const Font& font)
 489     {
 490         FT_Face face = FreeTypeInterface::getInstance()
 491                             ->createFT_Face (font.getTypefaceName(), font.isBold(), font.isItalic());
 492
 493         if (face == 0)
 494         {
 495            #if JUCE_DEBUG
 496             String msg ("Failed to create typeface: ");
 497             msg << font.getTypefaceName() << " " << (font.isBold() ? 'B' : ' ') << (font.isItalic() ? 'I' : ' ');
 498             DBG (msg);
 499            #endif
 500         }
 501         else
 502         {
 503             setCharacteristics (font.getTypefaceName(),
 504                                 face->ascender / (float) (face->ascender - face->descender),
 505                                 font.isBold(), font.isItalic(),
 506                                 L' ');
 507         }
 508     }
 509
 510     bool loadGlyphIfPossible (juce_wchar character)
 511     {
 512         return FreeTypeInterface::getInstance()
 513                     ->addGlyphToFont (character, name, isBold, isItalic, *this);
 514     }
 515 };
 516
 517 Typeface::Ptr Typeface::createSystemTypefaceFor (const Font& font)
 518 {
 519     return new FreetypeTypeface (font);
 520 }
 521
 522 //==============================================================================
 523 StringArray Font::findAllTypefaceNames()
 524 {
 525     StringArray s;
 526     FreeTypeInterface::getInstance()->getFamilyNames (s);
 527     s.sort (true);
 528     return s;
 529 }
 530
 531 namespace LinuxFontHelpers
 532 {
 533     String pickBestFont (const StringArray& names,
 534                          const char* const* choicesString)
 535     {
 536         const StringArray choices (choicesString);
 537
 538         int i, j;
 539         for (j = 0; j < choices.size(); ++j)
 540             if (names.contains (choices[j], true))
 541                 return choices[j];
 542
 543         for (j = 0; j < choices.size(); ++j)
 544             for (i = 0; i < names.size(); i++)
 545                 if (names[i].startsWithIgnoreCase (choices[j]))
 546                     return names[i];
 547
 548         for (j = 0; j < choices.size(); ++j)
 549             for (i = 0; i < names.size(); i++)
 550                 if (names[i].containsIgnoreCase (choices[j]))
 551                     return names[i];
 552
 553         return names[0];
 554     }
 555
 556     String getDefaultSansSerifFontName()
 557     {
 558         StringArray allFonts;
 559         FreeTypeInterface::getInstance()->getSansSerifNames (allFonts);
 560
 561         const char* targets[] = { "Verdana", "Bitstream Vera Sans", "Luxi Sans", "Sans", 0 };
 562         return pickBestFont (allFonts, targets);
 563     }
 564
 565     String getDefaultSerifFontName()
 566     {
 567         StringArray allFonts;
 568         FreeTypeInterface::getInstance()->getSerifNames (allFonts);
 569
 570         const char* targets[] = { "Bitstream Vera Serif", "Times", "Nimbus Roman", "Serif", 0 };
 571         return pickBestFont (allFonts, targets);
 572     }
 573
 574     String getDefaultMonospacedFontName()
 575     {
 576         StringArray allFonts;
 577         FreeTypeInterface::getInstance()->getMonospacedNames (allFonts);
 578
 579         const char* targets[] = { "Bitstream Vera Sans Mono", "Courier", "Sans Mono", "Mono", 0 };
 580         return pickBestFont (allFonts, targets);
 581     }
 582 }
 583
 584 void Font::getPlatformDefaultFontNames (String& defaultSans, String& defaultSerif, String& defaultFixed, String& /*defaultFallback*/)
 585 {
 586     defaultSans = LinuxFontHelpers::getDefaultSansSerifFontName();
 587     defaultSerif = LinuxFontHelpers::getDefaultSerifFontName();
 588     defaultFixed = LinuxFontHelpers::getDefaultMonospacedFontName();
 589 }
 590
 591 #endif