0031079: Visualization - embed minimal fallback font
[occt.git] / src / Font / Font_FontMgr.cxx
1 // Created on: 2008-01-20
2 // Created by: Alexander A. BORODIN
3 // Copyright (c) 2008-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <Font_FontMgr.hxx>
17
18 #include <Font_NameOfFont.hxx>
19 #include <Font_FTLibrary.hxx>
20 #include <Font_SystemFont.hxx>
21 #include <Message.hxx>
22 #include <Message_Messenger.hxx>
23 #include <NCollection_List.hxx>
24 #include <NCollection_Map.hxx>
25 #include <OSD_Environment.hxx>
26 #include <Standard_Stream.hxx>
27 #include <Standard_Type.hxx>
28 #include <TCollection_HAsciiString.hxx>
29
30 #include <ft2build.h>
31 #include FT_FREETYPE_H
32 IMPLEMENT_STANDARD_RTTIEXT(Font_FontMgr,Standard_Transient)
33
34 #if defined(_WIN32)
35
36   #include <windows.h>
37   #include <stdlib.h>
38
39   #ifdef _MSC_VER
40     #pragma comment (lib, "freetype.lib")
41   #endif
42
43   namespace
44   {
45
46     // list of supported extensions
47     static Standard_CString Font_FontMgr_Extensions[] =
48     {
49       "ttf",
50       "otf",
51       "ttc",
52       NULL
53     };
54
55   };
56
57 #else
58
59   #include <OSD_DirectoryIterator.hxx>
60   #include <OSD_FileIterator.hxx>
61   #include <OSD_Path.hxx>
62   #include <OSD_File.hxx>
63   #include <OSD_OpenMode.hxx>
64   #include <OSD_Protection.hxx>
65
66   namespace
67   {
68
69     // list of supported extensions
70     static Standard_CString Font_FontMgr_Extensions[] =
71     {
72       "ttf",
73       "otf",
74       "ttc",
75       "pfa",
76       "pfb",
77     #ifdef __APPLE__
78       // Datafork TrueType (OS X), obsolete
79       //"dfont",
80     #endif
81       NULL
82     };
83
84   #if !defined(__ANDROID__) && !defined(__APPLE__)
85     // X11 configuration file in plain text format (obsolete - doesn't exists in modern distributives)
86     static Standard_CString myFontServiceConf[] = {"/etc/X11/fs/config",
87                                                    "/usr/X11R6/lib/X11/fs/config",
88                                                    "/usr/X11/lib/X11/fs/config",
89                                                    NULL
90                                                   };
91
92     // Although fontconfig library can be built for various platforms,
93     // practically it is useful only on desktop Linux distributions, where it is always packaged.
94     #include <fontconfig/fontconfig.h>
95   #endif
96
97   #ifdef __APPLE__
98     // default fonts paths in Mac OS X
99     static Standard_CString myDefaultFontsDirs[] = {"/System/Library/Fonts",
100                                                     "/Library/Fonts",
101                                                     NULL
102                                                    };
103   #else
104     // default fonts paths in most Unix systems (Linux and others)
105     static Standard_CString myDefaultFontsDirs[] = {"/system/fonts",         // Android
106                                                     "/usr/share/fonts",
107                                                     "/usr/local/share/fonts",
108                                                     NULL
109                                                    };
110   #endif
111
112     static void addDirsRecursively (const OSD_Path&                           thePath,
113                                     NCollection_Map<TCollection_AsciiString>& theDirsMap)
114     {
115       TCollection_AsciiString aDirName;
116       thePath.SystemName (aDirName);
117       if (!theDirsMap.Add (aDirName))
118       {
119         return;
120       }
121
122       for (OSD_DirectoryIterator aDirIterator (thePath, "*"); aDirIterator.More(); aDirIterator.Next())
123       {
124         OSD_Path aChildDirPath;
125         aDirIterator.Values().Path (aChildDirPath);
126
127         TCollection_AsciiString aChildDirName;
128         aChildDirPath.SystemName (aChildDirName);
129         if (!aChildDirName.IsEqual (".") && !aChildDirName.IsEqual (".."))
130         {
131           aChildDirName = aDirName + "/" + aChildDirName;
132           OSD_Path aPath (aChildDirName);
133           addDirsRecursively (aPath, theDirsMap);
134         }
135       }
136     }
137
138   } // anonymous namespace
139
140 #endif
141
142 // =======================================================================
143 // function : checkFont
144 // purpose  :
145 // =======================================================================
146 static Handle(Font_SystemFont) checkFont (const Handle(Font_FTLibrary)& theFTLib,
147                                           const Standard_CString        theFontPath)
148 {
149   FT_Face aFontFace;
150   FT_Error aFaceError = FT_New_Face (theFTLib->Instance(), theFontPath, 0, &aFontFace);
151   if (aFaceError != FT_Err_Ok)
152   {
153     return NULL;
154   }
155
156   Font_FontAspect anAspect = Font_FA_Regular;
157   if (aFontFace->style_flags == (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD))
158   {
159     anAspect = Font_FA_BoldItalic;
160   }
161   else if (aFontFace->style_flags == FT_STYLE_FLAG_ITALIC)
162   {
163     anAspect = Font_FA_Italic;
164   }
165   else if (aFontFace->style_flags == FT_STYLE_FLAG_BOLD)
166   {
167     anAspect = Font_FA_Bold;
168   }
169
170   Handle(Font_SystemFont) aResult;
171   if (aFontFace->family_name != NULL                           // skip broken fonts (error in FreeType?)
172    && FT_Select_Charmap (aFontFace, ft_encoding_unicode) == 0) // Font_FTFont supports only UNICODE fonts
173   {
174     aResult = new Font_SystemFont (aFontFace->family_name);
175     aResult->SetFontPath (anAspect, theFontPath);
176     // automatically identify some known single-line fonts
177     aResult->SetSingleStrokeFont (aResult->FontKey().StartsWith ("olf "));
178   }
179
180   FT_Done_Face (aFontFace);
181
182   return aResult;
183 }
184
185 // =======================================================================
186 // function : GetInstance
187 // purpose  :
188 // =======================================================================
189 Handle(Font_FontMgr) Font_FontMgr::GetInstance()
190 {
191   static Handle(Font_FontMgr) _mgr;
192   if (_mgr.IsNull())
193   {
194     _mgr = new Font_FontMgr();
195   }
196
197   return _mgr;
198 }
199
200 // =======================================================================
201 // function : ToUseUnicodeSubsetFallback
202 // purpose  :
203 // =======================================================================
204 Standard_Boolean& Font_FontMgr::ToUseUnicodeSubsetFallback()
205 {
206   static Standard_Boolean TheToUseUnicodeSubsetFallback = true;
207   return TheToUseUnicodeSubsetFallback;
208 }
209
210 // =======================================================================
211 // function : addFontAlias
212 // purpose  :
213 // =======================================================================
214 void Font_FontMgr::addFontAlias (const TCollection_AsciiString& theAliasName,
215                                  const Handle(Font_FontAliasSequence)& theAliases,
216                                  Font_FontAspect theAspect)
217 {
218   if (theAliases.IsNull()
219    || theAliases->IsEmpty())
220   {
221     return;
222   }
223
224   Handle(Font_FontAliasSequence) anAliases = theAliases;
225   if (theAspect != Font_FA_Undefined)
226   {
227     anAliases = new Font_FontAliasSequence();
228     for (Font_FontAliasSequence::Iterator anAliasIter (*theAliases); anAliasIter.More(); anAliasIter.Next())
229     {
230       const TCollection_AsciiString& aName = anAliasIter.Value().FontName;
231       anAliases->Append (Font_FontAlias (aName, theAspect));
232     }
233   }
234
235   TCollection_AsciiString anAliasName (theAliasName);
236   anAliasName.LowerCase();
237   myFontAliases.Bind (anAliasName, anAliases);
238 }
239
240 // =======================================================================
241 // function : Font_FontMgr
242 // purpose  :
243 // =======================================================================
244 Font_FontMgr::Font_FontMgr()
245 : myToTraceAliases (Standard_False)
246 {
247   Handle(Font_FontAliasSequence) aMono   = new Font_FontAliasSequence();
248   Handle(Font_FontAliasSequence) aSerif  = new Font_FontAliasSequence();
249   Handle(Font_FontAliasSequence) aSans   = new Font_FontAliasSequence();
250   Handle(Font_FontAliasSequence) aSymbol = new Font_FontAliasSequence();
251   Handle(Font_FontAliasSequence) aScript = new Font_FontAliasSequence();
252   Handle(Font_FontAliasSequence) aWinDin = new Font_FontAliasSequence();
253   Handle(Font_FontAliasSequence) anIris  = new Font_FontAliasSequence();
254   Handle(Font_FontAliasSequence) aCJK    = new Font_FontAliasSequence();
255   Handle(Font_FontAliasSequence) aKorean = new Font_FontAliasSequence();
256   Handle(Font_FontAliasSequence) anArab  = new Font_FontAliasSequence();
257
258   // best matches - pre-installed on Windows, some of them are pre-installed on macOS,
259   // and sometimes them can be found installed on other systems (by user)
260   aMono  ->Append (Font_FontAlias ("courier new"));
261   aSerif ->Append (Font_FontAlias ("times new roman"));
262   aSans  ->Append (Font_FontAlias ("arial"));
263   aSymbol->Append (Font_FontAlias ("symbol"));
264   aScript->Append (Font_FontAlias ("script"));
265   aWinDin->Append (Font_FontAlias ("wingdings"));
266   anIris ->Append (Font_FontAlias ("lucida console"));
267
268 #if defined(__ANDROID__)
269   // Noto font family is usually installed on Android 6+ devices
270   aMono  ->Append (Font_FontAlias ("noto mono"));
271   aSerif ->Append (Font_FontAlias ("noto serif"));
272   // Droid font family is usually installed on Android 4+ devices
273   aMono  ->Append (Font_FontAlias ("droid sans mono"));
274   aSerif ->Append (Font_FontAlias ("droid serif"));
275   aSans  ->Append (Font_FontAlias ("roboto")); // actually DroidSans.ttf
276 #elif !defined(_WIN32) && !defined(__APPLE__) //X11
277   aSerif ->Append (Font_FontAlias ("times"));
278   aSans  ->Append (Font_FontAlias ("helvetica"));
279   // GNU FreeFonts family is usually installed on Linux
280   aMono  ->Append (Font_FontAlias ("freemono"));
281   aSerif ->Append (Font_FontAlias ("freeserif"));
282   aSans  ->Append (Font_FontAlias ("freesans"));
283   // DejaVu font family is usually installed on Linux
284   aMono  ->Append (Font_FontAlias ("dejavu sans mono"));
285   aSerif ->Append (Font_FontAlias ("dejavu serif"));
286   aSans  ->Append (Font_FontAlias ("dejavu sans"));
287 #endif
288
289   // default CJK (Chinese/Japanese/Korean) fonts
290   aCJK   ->Append (Font_FontAlias ("simsun"));        // Windows
291   aCJK   ->Append (Font_FontAlias ("droid sans fallback")); // Android, Linux
292   aCJK   ->Append (Font_FontAlias ("noto sans sc"));  // Android
293
294 #if defined(_WIN32)
295   aKorean->Append (Font_FontAlias ("malgun gothic")); // introduced since Vista
296   aKorean->Append (Font_FontAlias ("gulim"));         // used on older systems (Windows XP)
297 #elif defined(__APPLE__)
298   aKorean->Append (Font_FontAlias ("applegothic"));
299   aKorean->Append (Font_FontAlias ("stfangsong"));
300 #endif
301   aKorean->Append (Font_FontAlias ("nanumgothic"));   // Android, Linux
302   aKorean->Append (Font_FontAlias ("noto sans kr"));  // Android
303   aKorean->Append (Font_FontAlias ("nanummyeongjo")); // Linux
304   aKorean->Append (Font_FontAlias ("noto serif cjk jp")); // Linux
305   aKorean->Append (Font_FontAlias ("noto sans cjk jp")); // Linux
306   aKorean->Append (Font_FontAlias ("droid sans fallback")); // Linux
307
308 #if defined(_WIN32)
309   anArab->Append (Font_FontAlias ("times new roman"));
310 #elif defined(__APPLE__)
311   anArab->Append (Font_FontAlias ("decotype naskh"));
312 #elif defined(__ANDROID__)
313   anArab->Append (Font_FontAlias ("droid arabic naskh"));
314   anArab->Append (Font_FontAlias ("noto naskh arabic"));
315 #endif
316
317   addFontAlias ("mono",              aMono);
318   addFontAlias ("courier",           aMono);                      // Font_NOF_ASCII_MONO
319   addFontAlias ("monospace",         aMono);                      // Font_NOF_MONOSPACE
320   addFontAlias ("rock",              aSans);                      // Font_NOF_CARTOGRAPHIC_SIMPLEX
321   addFontAlias ("sansserif",         aSans);                      // Font_NOF_SANS_SERIF
322   addFontAlias ("sans-serif",        aSans);
323   addFontAlias ("sans",              aSans);
324   addFontAlias ("arial",             aSans);
325   addFontAlias ("times",             aSerif);
326   addFontAlias ("serif",             aSerif);                     // Font_NOF_SERIF
327   addFontAlias ("times-roman",       aSerif);                     // Font_NOF_ASCII_SIMPLEX
328   addFontAlias ("times-bold",        aSerif, Font_FA_Bold);       // Font_NOF_ASCII_DUPLEX
329   addFontAlias ("times-italic",      aSerif, Font_FA_Italic);     // Font_NOF_ASCII_ITALIC_COMPLEX
330   addFontAlias ("times-bolditalic",  aSerif, Font_FA_BoldItalic); // Font_NOF_ASCII_ITALIC_TRIPLEX
331   addFontAlias ("symbol",            aSymbol);                    // Font_NOF_GREEK_MONO
332   addFontAlias ("iris",              anIris);                     // Font_NOF_KANJI_MONO
333   addFontAlias ("korean",            aKorean);                    // Font_NOF_KOREAN
334   addFontAlias ("cjk",               aCJK);                       // Font_NOF_CJK
335   addFontAlias ("nsimsun",           aCJK);
336   addFontAlias ("arabic",            anArab);                     // Font_NOF_ARABIC
337   addFontAlias (Font_NOF_SYMBOL_MONO,          aWinDin);
338   addFontAlias (Font_NOF_ASCII_SCRIPT_SIMPLEX, aScript);
339
340   myFallbackAlias = aSans;
341
342   InitFontDataBase();
343 }
344
345 // =======================================================================
346 // function : CheckFont
347 // purpose  :
348 // =======================================================================
349 Handle(Font_SystemFont) Font_FontMgr::CheckFont (Standard_CString theFontPath) const
350 {
351   Handle(Font_FTLibrary) aFtLibrary = new Font_FTLibrary();
352   return checkFont (aFtLibrary, theFontPath);
353 }
354
355 // =======================================================================
356 // function : RegisterFont
357 // purpose  :
358 // =======================================================================
359 Standard_Boolean Font_FontMgr::RegisterFont (const Handle(Font_SystemFont)& theFont,
360                                              const Standard_Boolean         theToOverride)
361 {
362   if (theFont.IsNull())
363   {
364     return Standard_False;
365   }
366
367   const Standard_Integer anOldIndex = myFontMap.FindIndex (theFont);
368   if (anOldIndex == 0)
369   {
370     myFontMap.Add (theFont);
371     return Standard_True;
372   }
373
374   Handle(Font_SystemFont) anOldFont = myFontMap.FindKey (anOldIndex);
375   for (int anAspectIter = 0; anAspectIter < Font_FontAspect_NB; ++anAspectIter)
376   {
377     if (anOldFont->FontPath ((Font_FontAspect )anAspectIter).IsEqual (theFont->FontPath ((Font_FontAspect )anAspectIter)))
378     {
379       continue;
380     }
381     else if (theToOverride
382          || !anOldFont->HasFontAspect ((Font_FontAspect )anAspectIter))
383     {
384       anOldFont->SetFontPath ((Font_FontAspect )anAspectIter, theFont->FontPath ((Font_FontAspect )anAspectIter));
385     }
386     else if (theFont->HasFontAspect ((Font_FontAspect )anAspectIter))
387     {
388       return Standard_False;
389     }
390   }
391   return Standard_True;
392 }
393
394 // =======================================================================
395 // function : ClearFontDataBase()
396 // purpose  :
397 // =======================================================================
398 void Font_FontMgr::ClearFontDataBase()
399 {
400   myFontMap.Clear();
401 }
402
403 // =======================================================================
404 // function : InitFontDataBase
405 // purpose  :
406 // =======================================================================
407 void Font_FontMgr::InitFontDataBase()
408 {
409   myFontMap.Clear();
410   Handle(Font_FTLibrary) aFtLibrary = new Font_FTLibrary();
411
412 #if defined(OCCT_UWP)
413   // system font files are not accessible
414   (void )aFtLibrary;
415 #elif defined(_WIN32)
416
417   // font directory is placed in "C:\Windows\Fonts\"
418   UINT aStrLength = GetSystemWindowsDirectoryA (NULL, 0);
419   if (aStrLength == 0)
420   {
421     return;
422   }
423
424   char* aWinDir = new char[aStrLength];
425   GetSystemWindowsDirectoryA (aWinDir, aStrLength);
426   TCollection_AsciiString aFontsDir (aWinDir);
427   aFontsDir.AssignCat ("\\Fonts\\");
428   delete[] aWinDir;
429
430   // read fonts list from registry
431   HKEY aFontsKey;
432   if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
433                      0, KEY_READ, &aFontsKey) != ERROR_SUCCESS)
434   {
435     return;
436   }
437
438   NCollection_Map<TCollection_AsciiString> aSupportedExtensions;
439   for (Standard_Integer anIter = 0; Font_FontMgr_Extensions[anIter] != NULL; ++anIter)
440   {
441     Standard_CString anExt = Font_FontMgr_Extensions[anIter];
442     aSupportedExtensions.Add (TCollection_AsciiString (anExt));
443   }
444
445   static const DWORD aBufferSize = 256;
446   char aNameBuff[aBufferSize];
447   char aPathBuff[aBufferSize];
448   DWORD aNameSize = aBufferSize;
449   DWORD aPathSize = aBufferSize;
450   for (DWORD anIter = 0;
451        RegEnumValueA (aFontsKey, anIter,
452                       aNameBuff, &aNameSize, NULL, NULL,
453                       (LPBYTE )aPathBuff, &aPathSize) != ERROR_NO_MORE_ITEMS;
454       ++anIter, aNameSize = aBufferSize, aPathSize = aBufferSize)
455   {
456     aPathBuff[(aPathSize < aBufferSize) ? aPathSize : (aBufferSize - 1)] = '\0'; // ensure string is NULL-terminated
457
458     TCollection_AsciiString aFontName (aNameBuff), aFontPath (aPathBuff);
459     if (aFontPath.Search ("\\") == -1)
460     {
461       aFontPath.Insert (1, aFontsDir); // make absolute path
462     }
463
464     // check file extension is in list of supported
465     const Standard_Integer anExtensionPosition = aFontPath.SearchFromEnd (".") + 1;
466     if (anExtensionPosition > 0 && anExtensionPosition < aFontPath.Length())
467     {
468       TCollection_AsciiString aFontExtension = aFontPath.SubString (anExtensionPosition, aFontPath.Length());
469       aFontExtension.LowerCase();
470       if (aSupportedExtensions.Contains (aFontExtension))
471       {
472         if (Handle(Font_SystemFont) aNewFont = checkFont (aFtLibrary, aFontPath.ToCString()))
473         {
474           RegisterFont (aNewFont, false);
475         }
476       }
477     }
478   }
479
480   // close registry key
481   RegCloseKey (aFontsKey);
482
483 #else
484
485   NCollection_Map<TCollection_AsciiString> aMapOfFontsDirs;
486 #if !defined(__ANDROID__) && !defined(__APPLE__)
487   if (FcConfig* aFcCfg = FcInitLoadConfig())
488   {
489     if (FcStrList* aFcFontDir = FcConfigGetFontDirs (aFcCfg))
490     {
491       for (;;)
492       {
493         FcChar8* aFcFolder = FcStrListNext (aFcFontDir);
494         if (aFcFolder == NULL)
495         {
496           break;
497         }
498
499         TCollection_AsciiString aPathStr ((const char* )aFcFolder);
500         OSD_Path aPath (aPathStr);
501         addDirsRecursively (aPath, aMapOfFontsDirs);
502       }
503       FcStrListDone (aFcFontDir);
504     }
505     FcConfigDestroy (aFcCfg);
506   }
507
508   const OSD_Protection aProtectRead (OSD_R, OSD_R, OSD_R, OSD_R);
509   if (aMapOfFontsDirs.IsEmpty())
510   {
511     Message::DefaultMessenger()->Send ("Font_FontMgr, fontconfig library returns an empty folder list", Message_Alarm);
512
513     // read fonts directories from font service config file (obsolete)
514     for (Standard_Integer anIter = 0; myFontServiceConf[anIter] != NULL; ++anIter)
515     {
516       const TCollection_AsciiString aFileOfFontsPath (myFontServiceConf[anIter]);
517       OSD_File aFile (aFileOfFontsPath);
518       if (!aFile.Exists())
519       {
520         continue;
521       }
522
523       aFile.Open (OSD_ReadOnly, aProtectRead);
524       if (!aFile.IsOpen())
525       {
526         continue;
527       }
528
529       Standard_Integer aNByte = 256;
530       Standard_Integer aNbyteRead;
531       TCollection_AsciiString aStr; // read string with information
532       while (!aFile.IsAtEnd())
533       {
534         Standard_Integer aLocation = -1;
535         Standard_Integer aPathLocation = -1;
536
537         aFile.ReadLine (aStr, aNByte, aNbyteRead); // reading 1 line (256 bytes)
538         aLocation = aStr.Search ("catalogue=");
539         if (aLocation < 0)
540         {
541           aLocation = aStr.Search ("catalogue =");
542         }
543
544         aPathLocation = aStr.Search ("/");
545         if (aLocation > 0 && aPathLocation > 0)
546         {
547           aStr = aStr.Split (aPathLocation - 1);
548           TCollection_AsciiString aFontPath;
549           Standard_Integer aPathNumber = 1;
550           do
551           {
552             // Getting directory paths, which can be splitted by "," or ":"
553             aFontPath = aStr.Token (":,", aPathNumber);
554             aFontPath.RightAdjust();
555             if (!aFontPath.IsEmpty())
556             {
557               OSD_Path aPath(aFontPath);
558               addDirsRecursively (aPath, aMapOfFontsDirs);
559             }
560             aPathNumber++;
561           }
562           while (!aFontPath.IsEmpty());
563         }
564       }
565       aFile.Close();
566     }
567   }
568 #endif
569
570   // append default directories
571   for (Standard_Integer anIter = 0; myDefaultFontsDirs[anIter] != NULL; ++anIter)
572   {
573     Standard_CString anItem = myDefaultFontsDirs[anIter];
574     TCollection_AsciiString aPathStr (anItem);
575     OSD_Path aPath (aPathStr);
576     addDirsRecursively (aPath, aMapOfFontsDirs);
577   }
578
579   NCollection_Map<TCollection_AsciiString> aSupportedExtensions;
580   for (Standard_Integer anIter = 0; Font_FontMgr_Extensions[anIter] != NULL; ++anIter)
581   {
582     Standard_CString anExt = Font_FontMgr_Extensions[anIter];
583     aSupportedExtensions.Add (TCollection_AsciiString (anExt));
584   }
585
586   for (NCollection_Map<TCollection_AsciiString>::Iterator anIter (aMapOfFontsDirs);
587        anIter.More(); anIter.Next())
588   {
589   #if !defined(__ANDROID__) && !defined(__APPLE__)
590     OSD_File aReadFile (anIter.Value() + "/fonts.dir");
591     if (!aReadFile.Exists())
592     {
593   #endif
594       OSD_Path aFolderPath (anIter.Value());
595       for (OSD_FileIterator aFileIter (aFolderPath, "*"); aFileIter.More(); aFileIter.Next())
596       {
597         OSD_Path aFontFilePath;
598         aFileIter.Values().Path (aFontFilePath);
599
600         TCollection_AsciiString aFontFileName;
601         aFontFilePath.SystemName (aFontFileName);
602         aFontFileName = anIter.Value() + "/" + aFontFileName;
603
604         if (Handle(Font_SystemFont) aNewFont = checkFont (aFtLibrary, aFontFileName.ToCString()))
605         {
606           RegisterFont (aNewFont, false);
607         }
608       }
609
610   #if !defined(__ANDROID__) && !defined(__APPLE__)
611       continue;
612     }
613
614     aReadFile.Open (OSD_ReadOnly, aProtectRead);
615     if (!aReadFile.IsOpen())
616     {
617       continue; // invalid fonts directory
618     }
619
620     Standard_Integer aNbyteRead, aNByte = 256;
621     TCollection_AsciiString aLine (aNByte);
622     Standard_Boolean isFirstLine = Standard_True;
623     const TCollection_AsciiString anEncoding ("iso8859-1\n");
624     while (!aReadFile.IsAtEnd())
625     {
626       aReadFile.ReadLine (aLine, aNByte, aNbyteRead);
627       if (isFirstLine)
628       {
629         // first line contains the number of fonts in this file
630         // just ignoring it...
631         isFirstLine = Standard_False;
632         continue;
633       }
634
635       Standard_Integer anExtensionPosition = aLine.Search (".") + 1;
636       if (anExtensionPosition == 0)
637       {
638         continue; // can't find extension position in the font description
639       }
640
641       Standard_Integer anEndOfFileName = aLine.Location (" ", anExtensionPosition, aLine.Length()) - 1;
642       if (anEndOfFileName < 0 || anEndOfFileName < anExtensionPosition)
643       {
644         continue; // font description have empty extension
645       }
646
647       TCollection_AsciiString aFontExtension = aLine.SubString (anExtensionPosition, anEndOfFileName);
648       aFontExtension.LowerCase();
649       if (aSupportedExtensions.Contains (aFontExtension) && (aLine.Search (anEncoding) > 0))
650       {
651         // In current implementation use fonts with ISO-8859-1 coding page.
652         // OCCT not give to manage coding page by means of programm interface.
653         // TODO: make high level interface for choosing necessary coding page.
654         TCollection_AsciiString aXLFD (aLine.SubString (anEndOfFileName + 2, aLine.Length()));
655         TCollection_AsciiString aFontPath (anIter.Value().ToCString());
656         if (aFontPath.SearchFromEnd ("/") != aFontPath.Length())
657         {
658           aFontPath.AssignCat ("/");
659         }
660         TCollection_AsciiString aFontFileName (aLine.SubString (1, anEndOfFileName));
661         aFontPath.AssignCat (aFontFileName);
662         if (Handle(Font_SystemFont) aNewFont = checkFont (aFtLibrary, aFontPath.ToCString()))
663         {
664           RegisterFont (aNewFont, false);
665           if (!aXLFD.IsEmpty()
666             && aXLFD.Search ("-0-0-0-0-") != -1) // ignore non-resizable fonts
667           {
668             const TCollection_AsciiString anXName = aXLFD.Token ("-", 2);
669             Font_FontAspect anXAspect = Font_FA_Regular;
670             if (aXLFD.Token ("-", 3).IsEqual ("bold")
671              && (aXLFD.Token ("-", 4).IsEqual ("i")
672               || aXLFD.Token ("-", 4).IsEqual ("o")))
673             {
674               anXAspect = Font_FA_BoldItalic;
675             }
676             else if (aXLFD.Token ("-", 3).IsEqual ("bold"))
677             {
678               anXAspect = Font_FA_Bold;
679             }
680             else if (aXLFD.Token ("-", 4).IsEqual ("i")
681                   || aXLFD.Token ("-", 4).IsEqual ("o"))
682             {
683               anXAspect = Font_FA_Italic;
684             }
685
686             Handle(Font_SystemFont) aNewFontFromXLFD = new Font_SystemFont (anXName);
687             aNewFontFromXLFD->SetFontPath (anXAspect, aFontPath);
688             if (!aNewFont->IsEqual (aNewFontFromXLFD))
689             {
690               RegisterFont (aNewFontFromXLFD, false);
691             }
692           }
693         }
694       }
695     }
696     aReadFile.Close();
697   #endif
698   }
699 #endif
700 }
701
702 // =======================================================================
703 // function : GetAvailableFontsNames
704 // purpose  :
705 // =======================================================================
706 void Font_FontMgr::GetAvailableFontsNames (TColStd_SequenceOfHAsciiString& theFontsNames) const
707 {
708   theFontsNames.Clear();
709   for (NCollection_IndexedMap<Handle(Font_SystemFont), Font_SystemFont>::Iterator aFontIter (myFontMap);
710        aFontIter.More(); aFontIter.Next())
711   {
712     const Handle(Font_SystemFont)& aFont = aFontIter.Value();
713     theFontsNames.Append (new TCollection_HAsciiString(aFont->FontName()));
714   }
715 }
716
717 // =======================================================================
718 // function : GetFont
719 // purpose  :
720 // =======================================================================
721 Handle(Font_SystemFont) Font_FontMgr::GetFont (const Handle(TCollection_HAsciiString)& theFontName,
722                                                const Font_FontAspect  theFontAspect,
723                                                const Standard_Integer theFontSize) const
724 {
725   if ((theFontSize < 2 && theFontSize != -1) || theFontName.IsNull())
726   {
727     return Handle(Font_SystemFont)();
728   }
729
730   Handle(Font_SystemFont) aFont = myFontMap.Find (theFontName->String());
731   return (aFont.IsNull()
732        || theFontAspect == Font_FontAspect_UNDEFINED
733        || aFont->HasFontAspect (theFontAspect))
734        ? aFont
735        : Handle(Font_SystemFont)();
736 }
737
738 // =======================================================================
739 // function : GetFont
740 // purpose  :
741 // =======================================================================
742 Handle(Font_SystemFont) Font_FontMgr::GetFont (const TCollection_AsciiString& theFontName) const
743 {
744   return myFontMap.Find (theFontName);
745 }
746
747 // =======================================================================
748 // function : FindFallbackFont
749 // purpose  :
750 // =======================================================================
751 Handle(Font_SystemFont) Font_FontMgr::FindFallbackFont (Font_UnicodeSubset theSubset,
752                                                         Font_FontAspect theFontAspect) const
753 {
754   Font_FontAspect aFontAspect = theFontAspect;
755   Handle(Font_SystemFont) aFont;
756   switch (theSubset)
757   {
758     case Font_UnicodeSubset_Western: aFont = FindFont (Font_NOF_SANS_SERIF, Font_StrictLevel_Aliases, aFontAspect, false); break;
759     case Font_UnicodeSubset_Korean:  aFont = FindFont (Font_NOF_KOREAN,     Font_StrictLevel_Aliases, aFontAspect, false); break;
760     case Font_UnicodeSubset_CJK:     aFont = FindFont (Font_NOF_CJK,        Font_StrictLevel_Aliases, aFontAspect, false); break;
761     case Font_UnicodeSubset_Arabic:  aFont = FindFont (Font_NOF_ARABIC,     Font_StrictLevel_Aliases, aFontAspect, false); break;
762   }
763   if (aFont.IsNull())
764   {
765     const char* aRange = "";
766     switch (theSubset)
767     {
768       case Font_UnicodeSubset_Western: aRange = "Western"; break;
769       case Font_UnicodeSubset_Korean:  aRange = "Korean";  break;
770       case Font_UnicodeSubset_CJK:     aRange = "CJK";     break;
771       case Font_UnicodeSubset_Arabic:  aRange = "Arabic";  break;
772     }
773     Message::DefaultMessenger()->Send (TCollection_AsciiString("Font_FontMgr, error: unable to find ") + aRange + " fallback font!", Message_Fail);
774   }
775   return aFont;
776 }
777
778 // =======================================================================
779 // function : FindFont
780 // purpose  :
781 // =======================================================================
782 Handle(Font_SystemFont) Font_FontMgr::FindFont (const TCollection_AsciiString& theFontName,
783                                                 Font_StrictLevel theStrictLevel,
784                                                 Font_FontAspect& theFontAspect,
785                                                 Standard_Boolean theDoFailMsg) const
786 {
787   TCollection_AsciiString aFontName (theFontName);
788   aFontName.LowerCase();
789   Handle(Font_SystemFont) aFont = myFontMap.Find (aFontName);
790   if (!aFont.IsNull()
791     || theStrictLevel == Font_StrictLevel_Strict)
792   {
793     return aFont;
794   }
795
796   // Trying to use font names mapping
797   for (int aPass = 0; aPass < 2; ++aPass)
798   {
799     Handle(Font_FontAliasSequence) anAliases;
800     if (aPass == 0)
801     {
802       myFontAliases.Find (aFontName, anAliases);
803     }
804     else if (theStrictLevel == Font_StrictLevel_Any)
805     {
806       anAliases = myFallbackAlias;
807     }
808
809     if (anAliases.IsNull()
810      || anAliases->IsEmpty())
811     {
812       continue;
813     }
814
815     bool isAliasUsed = false, isBestAlias = false;
816     for (Font_FontAliasSequence::Iterator anAliasIter (*anAliases); anAliasIter.More(); anAliasIter.Next())
817     {
818       const Font_FontAlias& anAlias = anAliasIter.Value();
819       if (Handle(Font_SystemFont) aFont2 = myFontMap.Find (anAlias.FontName))
820       {
821         if (aFont.IsNull())
822         {
823           aFont = aFont2;
824           isAliasUsed = true;
825         }
826
827         if ((anAlias.FontAspect != Font_FontAspect_UNDEFINED
828           && aFont2->HasFontAspect (anAlias.FontAspect)))
829         {
830           // special case - alias refers to styled font (e.g. "times-bold")
831           isBestAlias = true;
832           theFontAspect = anAlias.FontAspect;
833           break;
834         }
835         else if (anAlias.FontAspect == Font_FontAspect_UNDEFINED
836               && (theFontAspect == Font_FontAspect_UNDEFINED
837                 || aFont2->HasFontAspect (theFontAspect)))
838         {
839           isBestAlias = true;
840           break;
841         }
842       }
843     }
844
845     if (aPass == 0)
846     {
847       if (isAliasUsed && myToTraceAliases)
848       {
849         Message::DefaultMessenger()->Send (TCollection_AsciiString("Font_FontMgr, using font alias '") + aFont->FontName() + "'"
850                                             " instead of requested '" + theFontName +"'", Message_Trace);
851       }
852       if (isBestAlias)
853       {
854         return aFont;
855       }
856       else if (!aFont.IsNull())
857       {
858         break;
859       }
860     }
861   }
862
863   if (aFont.IsNull()
864    && theStrictLevel == Font_StrictLevel_Any)
865   {
866     // try finding ANY font in case if even default fallback alias myFallbackAlias cannot be found
867     aFont = myFontMap.Find (TCollection_AsciiString());
868   }
869   if (aFont.IsNull())
870   {
871     if (theDoFailMsg)
872     {
873       Message::DefaultMessenger()->Send (TCollection_AsciiString("Font_FontMgr, error: unable to find any font!"), Message_Fail);
874     }
875     return Handle(Font_SystemFont)();
876   }
877
878   if ((theFontAspect != Font_FA_Undefined
879     && !aFont->HasFontAspect (theFontAspect))
880    || (!aFontName.IsEmpty()
881     && !aFontName.IsEqual (aFont->FontKey())))
882   {
883     TCollection_AsciiString aDesc = TCollection_AsciiString() + "'" + theFontName + "'"
884                                   + TCollection_AsciiString() + " [" + Font_FontMgr::FontAspectToString (theFontAspect) + "]";
885     Message::DefaultMessenger()->Send (TCollection_AsciiString("Font_FontMgr, warning: unable to find font ")
886                                      + aDesc + "; " + aFont->ToString() + " is used instead");
887   }
888   return aFont;
889 }
890
891 // =======================================================================
892 // function : Font_FontMap::Find
893 // purpose  :
894 // =======================================================================
895 Handle(Font_SystemFont) Font_FontMgr::Font_FontMap::Find (const TCollection_AsciiString& theFontName) const
896 {
897   if (IsEmpty())
898   {
899     return Handle(Font_SystemFont)();
900   }
901   else if (theFontName.IsEmpty())
902   {
903     return FindKey (1); // return any font
904   }
905
906   TCollection_AsciiString aFontName (theFontName);
907   aFontName.LowerCase();
908   for (IndexedMapNode* aNodeIter = (IndexedMapNode* )myData1[::HashCode (aFontName, NbBuckets())];
909        aNodeIter != NULL; aNodeIter = (IndexedMapNode* )aNodeIter->Next())
910   {
911     const Handle(Font_SystemFont)& aKey = aNodeIter->Key1();
912     if (aKey->FontKey().IsEqual (aFontName))
913     {
914       return aKey;
915     }
916   }
917   return Handle(Font_SystemFont)();
918 }