1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qplatformdefs.h>

    43 

    44 #include <qdatetime.h>

    45 #include <qdebug.h>

    46 #include <qpaintdevice.h>

    47 

    48 #include <private/qt_x11_p.h>

    49 #include "qx11info_x11.h"

    50 #include <qdebug.h>

    51 #include <qfile.h>

    52 #include <qtemporaryfile.h>

    53 #include <qabstractfileengine.h>

    54 #include <qmath.h>

    55 

    56 #include <ctype.h>

    57 #include <stdlib.h>

    58 

    59 #include <sys/types.h>

    60 #include <sys/stat.h>

    61 #include <fcntl.h>

    62 #include <sys/mman.h>

    63 

    64 #include <private/qfontengine_x11_p.h>

    65 

    66 #ifndef QT_NO_FONTCONFIG

    67 #include <ft2build.h>

    68 #include FT_FREETYPE_H

    69 

    70 #if FC_VERSION >= 20402

    71 #include <fontconfig/fcfreetype.h>

    72 #endif

    73 #endif

    74 

    75 QT_BEGIN_NAMESPACE

    76 

    77 // from qfont_x11.cpp

    78 extern double qt_pointSize(double pixelSize, int dpi);

    79 extern double qt_pixelSize(double pointSize, int dpi);

    80 

    81 static inline void capitalize (char *s)

    82 {

    83     bool space = true;

    84     while(*s) {

    85         if (space)

    86             *s = toupper(*s);

    87         space = (*s == ' ');

    88         ++s;

    89     }

    90 }

    91 

    92 

    93 /*

    94   To regenerate the writingSystems_for_xlfd_encoding table, run

    95   'util/unicode/x11/makeencodings' and paste the generated

    96   'encodings.c' here.

    97 */

    98 // ----- begin of generated code -----

    99 

   100 #define make_tag( c1, c2, c3, c4 )                              \

   101     ((((unsigned int)c1)<<24) | (((unsigned int)c2)<<16) |      \

   102      (((unsigned int)c3)<<8) | ((unsigned int)c4))

   103 

   104 struct XlfdEncoding {

   105     const char *name;

   106     int id;

   107     int mib;

   108     unsigned int hash1;

   109     unsigned int hash2;

   110 };

   111 

   112 static const XlfdEncoding xlfd_encoding[] = {

   113     { "iso8859-1", 0, 4, make_tag('i','s','o','8'), make_tag('5','9','-','1') },

   114     { "iso8859-2", 1, 5, make_tag('i','s','o','8'), make_tag('5','9','-','2') },

   115     { "iso8859-3", 2, 6, make_tag('i','s','o','8'), make_tag('5','9','-','3') },

   116     { "iso8859-4", 3, 7, make_tag('i','s','o','8'), make_tag('5','9','-','4') },

   117     { "iso8859-9", 4, 12, make_tag('i','s','o','8'), make_tag('5','9','-','9') },

   118     { "iso8859-10", 5, 13, make_tag('i','s','o','8'), make_tag('9','-','1','0') },

   119     { "iso8859-13", 6, 109, make_tag('i','s','o','8'), make_tag('9','-','1','3') },

   120     { "iso8859-14", 7, 110, make_tag('i','s','o','8'), make_tag('9','-','1','4') },

   121     { "iso8859-15", 8, 111, make_tag('i','s','o','8'), make_tag('9','-','1','5') },

   122     { "hp-roman8", 9, 2004, make_tag('h','p','-','r'), make_tag('m','a','n','8') },

   123     { "iso8859-5", 10, 8, make_tag('i','s','o','8'), make_tag('5','9','-','5') },

   124     { "*-cp1251", 11, 2251, 0, make_tag('1','2','5','1') },

   125     { "koi8-ru", 12, 2084, make_tag('k','o','i','8'), make_tag('8','-','r','u') },

   126     { "koi8-u", 13, 2088, make_tag('k','o','i','8'), make_tag('i','8','-','u') },

   127     { "koi8-r", 14, 2084, make_tag('k','o','i','8'), make_tag('i','8','-','r') },

   128     { "iso8859-7", 15, 10, make_tag('i','s','o','8'), make_tag('5','9','-','7') },

   129     { "iso8859-8", 16, 85, make_tag('i','s','o','8'), make_tag('5','9','-','8') },

   130     { "gb18030-0", 17, -114, make_tag('g','b','1','8'), make_tag('3','0','-','0') },

   131     { "gb18030.2000-0", 18, -113, make_tag('g','b','1','8'), make_tag('0','0','-','0') },

   132     { "gbk-0", 19, -113, make_tag('g','b','k','-'), make_tag('b','k','-','0') },

   133     { "gb2312.*-0", 20, 57, make_tag('g','b','2','3'), 0 },

   134     { "jisx0201*-0", 21, 15, make_tag('j','i','s','x'), 0 },

   135     { "jisx0208*-0", 22, 63, make_tag('j','i','s','x'), 0 },

   136     { "ksc5601*-*", 23, 36, make_tag('k','s','c','5'), 0 },

   137     { "big5hkscs-0", 24, -2101, make_tag('b','i','g','5'), make_tag('c','s','-','0') },

   138     { "hkscs-1", 25, -2101, make_tag('h','k','s','c'), make_tag('c','s','-','1') },

   139     { "big5*-*", 26, -2026, make_tag('b','i','g','5'), 0 },

   140     { "tscii-*", 27, 2028, make_tag('t','s','c','i'), 0 },

   141     { "tis620*-*", 28, 2259, make_tag('t','i','s','6'), 0 },

   142     { "iso8859-11", 29, 2259, make_tag('i','s','o','8'), make_tag('9','-','1','1') },

   143     { "mulelao-1", 30, -4242, make_tag('m','u','l','e'), make_tag('a','o','-','1') },

   144     { "ethiopic-unicode", 31, 0, make_tag('e','t','h','i'), make_tag('c','o','d','e') },

   145     { "iso10646-1", 32, 0, make_tag('i','s','o','1'), make_tag('4','6','-','1') },

   146     { "unicode-*", 33, 0, make_tag('u','n','i','c'), 0 },

   147     { "*-symbol", 34, 0, 0, make_tag('m','b','o','l') },

   148     { "*-fontspecific", 35, 0, 0, make_tag('i','f','i','c') },

   149     { "fontspecific-*", 36, 0, make_tag('f','o','n','t'), 0 },

   150     { 0, 0, 0, 0, 0 }

   151 };

   152 

   153 static const char writingSystems_for_xlfd_encoding[sizeof(xlfd_encoding)][QFontDatabase::WritingSystemsCount] = {

   154     // iso8859-1

   155     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   156       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   157       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   158       0, 0 },

   159     // iso8859-2

   160     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   161       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   162       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   163       0, 0 },

   164     // iso8859-3

   165     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   166       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   167       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   168       0, 0 },

   169     // iso8859-4

   170     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   171       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   172       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   173       0, 0 },

   174     // iso8859-9

   175     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   176       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   177       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   178       0, 0 },

   179     // iso8859-10

   180     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   181       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   182       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   183       0, 0 },

   184     // iso8859-13

   185     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   186       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   187       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   188       0, 0 },

   189     // iso8859-14

   190     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   191       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   192       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   193       0, 0 },

   194     // iso8859-15

   195     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   196       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   197       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   198       0, 0 },

   199     // hp-roman8

   200     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,

   201       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   202       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   203       0, 0 },

   204     // iso8859-5

   205     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,

   206       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   207       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   208       0, 0 },

   209     // *-cp1251

   210     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,

   211       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   212       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   213       0, 0 },

   214     // koi8-ru

   215     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,

   216       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   217       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   218       0, 0 },

   219     // koi8-u

   220     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,

   221       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   222       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   223       0, 0 },

   224     // koi8-r

   225     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,

   226       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   227       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   228       0, 0 },

   229     // iso8859-7

   230     { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,

   231       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   232       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   233       0, 0 },

   234     // iso8859-8

   235     { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

   236       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   237       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   238       0, 0 },

   239     // gb18030-0

   240     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   241       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   242       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

   243       0, 0 },

   244     // gb18030.2000-0

   245     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   246       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   247       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

   248       0, 0 },

   249     // gbk-0

   250     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   251       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   252       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

   253       0, 0 },

   254     // gb2312.*-0

   255     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   256       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   257       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

   258       0, 0 },

   259     // jisx0201*-0

   260     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   261       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   262       0, 0, 0, 0, 0, 0, 0, 1, 0, 0,

   263       0, 0 },

   264     // jisx0208*-0

   265     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   266       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   267       0, 0, 0, 0, 0, 0, 0, 1, 0, 0,

   268       0, 0 },

   269     // ksc5601*-*

   270     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   271       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   272       0, 0, 0, 0, 0, 0, 0, 0, 1, 0,

   273       0, 0 },

   274     // big5hkscs-0

   275     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   276       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   277       0, 0, 0, 0, 0, 0, 1, 0, 0, 0,

   278       0, 0 },

   279     // hkscs-1

   280     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   281       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   282       0, 0, 0, 0, 0, 0, 1, 0, 0, 0,

   283       0, 0 },

   284     // big5*-*

   285     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   286       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   287       0, 0, 0, 0, 0, 0, 1, 0, 0, 0,

   288       0, 0 },

   289     // tscii-*

   290     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   291       0, 0, 0, 0, 1, 0, 0, 0, 0, 0,

   292       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   293       0, 0 },

   294     // tis620*-*

   295     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   296       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

   297       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   298       0, 0 },

   299     // iso8859-11

   300     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   301       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

   302       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   303       0, 0 },

   304     // mulelao-1

   305     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   306       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   307       1, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   308       0, 0 },

   309     // ethiopic-unicode

   310     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   311       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   312       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   313       0, 0 },

   314     // iso10646-1

   315     { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,

   316       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

   317       1, 1, 0, 1, 0, 1, 1, 0, 0, 0,

   318       0, 0 },

   319     // unicode-*

   320     { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,

   321       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

   322       1, 1, 0, 1, 0, 1, 1, 0, 0, 0,

   323       0, 0 },

   324     // *-symbol

   325     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   326       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   327       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   328       1, 0 },

   329     // *-fontspecific

   330     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   331       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   332       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   333       1, 0 },

   334     // fontspecific-*

   335     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   336       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   337       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   338       1, 0 }

   339 

   340 };

   341 

   342 // ----- end of generated code -----

   343 

   344 

   345 const int numEncodings = sizeof(xlfd_encoding) / sizeof(XlfdEncoding) - 1;

   346 

   347 int qt_xlfd_encoding_id(const char *encoding)

   348 {

   349     // qDebug("looking for encoding id for '%s'", encoding);

   350     int len = strlen(encoding);

   351     if (len < 4)

   352         return -1;

   353     unsigned int hash1 = make_tag(encoding[0], encoding[1], encoding[2], encoding[3]);

   354     const char *ch = encoding + len - 4;

   355     unsigned int hash2 = make_tag(ch[0], ch[1], ch[2], ch[3]);

   356 

   357     const XlfdEncoding *enc = xlfd_encoding;

   358     for (; enc->name; ++enc) {

   359         if ((enc->hash1 && enc->hash1 != hash1) ||

   360             (enc->hash2 && enc->hash2 != hash2))

   361             continue;

   362         // hashes match, do a compare if strings match

   363         // the enc->name can contain '*'s we have to interpret correctly

   364         const char *n = enc->name;

   365         const char *e = encoding;

   366         while (1) {

   367             // qDebug("bol: *e='%c', *n='%c'", *e, *n);

   368             if (*e == '\0') {

   369                 if (*n)

   370                     break;

   371                 // qDebug("found encoding id %d", enc->id);

   372                 return enc->id;

   373             }

   374             if (*e == *n) {

   375                 ++e;

   376                 ++n;

   377                 continue;

   378             }

   379             if (*n != '*')

   380                 break;

   381             ++n;

   382             // qDebug("skip: *e='%c', *n='%c'", *e, *n);

   383             while (*e && *e != *n)

   384                 ++e;

   385         }

   386     }

   387     // qDebug("couldn't find encoding %s", encoding);

   388     return -1;

   389 }

   390 

   391 int qt_mib_for_xlfd_encoding(const char *encoding)

   392 {

   393     int id = qt_xlfd_encoding_id(encoding);

   394     if (id != -1) return xlfd_encoding[id].mib;

   395     return 0;

   396 }

   397 

   398 int qt_encoding_id_for_mib(int mib)

   399 {

   400     const XlfdEncoding *enc = xlfd_encoding;

   401     for (; enc->name; ++enc) {

   402         if (enc->mib == mib)

   403             return enc->id;

   404     }

   405     return -1;

   406 }

   407 

   408 static const char * xlfd_for_id(int id)

   409 {

   410     // special case: -1 returns the "*-*" encoding, allowing us to do full

   411     // database population in a single X server round trip.

   412     if (id < 0 || id > numEncodings)

   413         return "*-*";

   414     return xlfd_encoding[id].name;

   415 }

   416 

   417 enum XLFDFieldNames {

   418     Foundry,

   419     Family,

   420     Weight,

   421     Slant,

   422     Width,

   423     AddStyle,

   424     PixelSize,

   425     PointSize,

   426     ResolutionX,

   427     ResolutionY,

   428     Spacing,

   429     AverageWidth,

   430     CharsetRegistry,

   431     CharsetEncoding,

   432     NFontFields

   433 };

   434 

   435 // Splits an X font name into fields separated by '-'

   436 static bool parseXFontName(char *fontName, char **tokens)

   437 {

   438     if (! fontName || fontName[0] == '0' || fontName[0] != '-') {

   439         tokens[0] = 0;

   440         return false;

   441     }

   442 

   443     int          i;

   444     ++fontName;

   445     for (i = 0; i < NFontFields && fontName && fontName[0]; ++i) {

   446         tokens[i] = fontName;

   447         for (;; ++fontName) {

   448             if (*fontName == '-')

   449                 break;

   450             if (! *fontName) {

   451                 fontName = 0;

   452                 break;

   453             }

   454         }

   455 

   456         if (fontName) *fontName++ = '\0';

   457     }

   458 

   459     if (i < NFontFields) {

   460         for (int j = i ; j < NFontFields; ++j)

   461             tokens[j] = 0;

   462         return false;

   463     }

   464 

   465     return true;

   466 }

   467 

   468 static inline bool isZero(char *x)

   469 {

   470     return (x[0] == '0' && x[1] == 0);

   471 }

   472 

   473 static inline bool isScalable(char **tokens)

   474 {

   475     return (isZero(tokens[PixelSize]) &&

   476             isZero(tokens[PointSize]) &&

   477             isZero(tokens[AverageWidth]));

   478 }

   479 

   480 static inline bool isSmoothlyScalable(char **tokens)

   481 {

   482     return (isZero(tokens[ResolutionX]) &&

   483             isZero(tokens[ResolutionY]));

   484 }

   485 

   486 static inline bool isFixedPitch(char **tokens)

   487 {

   488     return (tokens[Spacing][0] == 'm' ||

   489             tokens[Spacing][0] == 'c' ||

   490             tokens[Spacing][0] == 'M' ||

   491             tokens[Spacing][0] == 'C');

   492 }

   493 

   494 /*

   495   Fills in a font definition (QFontDef) from an XLFD (X Logical Font

   496   Description).

   497 

   498   Returns true if the given xlfd is valid.

   499 */

   500 bool qt_fillFontDef(const QByteArray &xlfd, QFontDef *fd, int dpi, QtFontDesc *desc)

   501 {

   502     char *tokens[NFontFields];

   503     QByteArray buffer = xlfd;

   504     if (! parseXFontName(buffer.data(), tokens))

   505         return false;

   506 

   507     capitalize(tokens[Family]);

   508     capitalize(tokens[Foundry]);

   509 

   510     fd->styleStrategy |= QFont::NoAntialias;

   511     fd->family = QString::fromLatin1(tokens[Family]);

   512     QString foundry = QString::fromLatin1(tokens[Foundry]);

   513     if (! foundry.isEmpty() && foundry != QLatin1String("*") && (!desc || desc->family->count > 1))

   514         fd->family +=

   515             QLatin1String(" [") + foundry + QLatin1Char(']');

   516 

   517     if (qstrlen(tokens[AddStyle]) > 0)

   518         fd->addStyle = QString::fromLatin1(tokens[AddStyle]);

   519     else

   520         fd->addStyle.clear();

   521 

   522     fd->pointSize = atoi(tokens[PointSize])/10.;

   523     fd->styleHint = QFont::AnyStyle;        // ### any until we match families

   524 

   525     char slant = tolower((uchar) tokens[Slant][0]);

   526     fd->style = (slant == 'o' ? QFont::StyleOblique : (slant == 'i' ? QFont::StyleItalic : QFont::StyleNormal));

   527     char fixed = tolower((uchar) tokens[Spacing][0]);

   528     fd->fixedPitch = (fixed == 'm' || fixed == 'c');

   529     fd->weight = getFontWeight(QLatin1String(tokens[Weight]));

   530 

   531     int r = atoi(tokens[ResolutionY]);

   532     fd->pixelSize = atoi(tokens[PixelSize]);

   533     // not "0" or "*", or required DPI

   534     if (r && fd->pixelSize && r != dpi) {

   535         // calculate actual pointsize for display DPI

   536         fd->pointSize = qt_pointSize(fd->pixelSize, dpi);

   537     } else if (fd->pixelSize == 0 && fd->pointSize) {

   538         // calculate pixel size from pointsize/dpi

   539         fd->pixelSize = qRound(qt_pixelSize(fd->pointSize, dpi));

   540     }

   541 

   542     return true;

   543 }

   544 

   545 /*

   546   Fills in a font definition (QFontDef) from the font properties in an

   547   XFontStruct.

   548 

   549   Returns true if the QFontDef could be filled with properties from

   550   the XFontStruct.

   551 */

   552 static bool qt_fillFontDef(XFontStruct *fs, QFontDef *fd, int dpi, QtFontDesc *desc)

   553 {

   554     unsigned long value;

   555     if (!fs || !XGetFontProperty(fs, XA_FONT, &value))

   556         return false;

   557 

   558     char *n = XGetAtomName(QX11Info::display(), value);

   559     QByteArray xlfd(n);

   560     if (n)

   561         XFree(n);

   562     return qt_fillFontDef(xlfd.toLower(), fd, dpi, desc);

   563 }

   564 

   565 

   566 static QtFontStyle::Key getStyle(char ** tokens)

   567 {

   568     QtFontStyle::Key key;

   569 

   570     char slant0 = tolower((uchar) tokens[Slant][0]);

   571 

   572     if (slant0 == 'r') {

   573         if (tokens[Slant][1]) {

   574             char slant1 = tolower((uchar) tokens[Slant][1]);

   575 

   576             if (slant1 == 'o')

   577                 key.style = QFont::StyleOblique;

   578             else if (slant1 == 'i')

   579                 key.style = QFont::StyleItalic;

   580         }

   581     } else if (slant0 == 'o')

   582         key.style = QFont::StyleOblique;

   583     else if (slant0 == 'i')

   584         key.style = QFont::StyleItalic;

   585 

   586     key.weight = getFontWeight(QLatin1String(tokens[Weight]));

   587 

   588     if (qstrcmp(tokens[Width], "normal") == 0) {

   589         key.stretch = 100;

   590     } else if (qstrcmp(tokens[Width], "semi condensed") == 0 ||

   591                qstrcmp(tokens[Width], "semicondensed") == 0) {

   592         key.stretch = 90;

   593     } else if (qstrcmp(tokens[Width], "condensed") == 0) {

   594         key.stretch = 80;

   595     } else if (qstrcmp(tokens[Width], "narrow") == 0) {

   596         key.stretch = 60;

   597     }

   598 

   599     return key;

   600 }

   601 

   602 

   603 static bool xlfdsFullyLoaded = false;

   604 static unsigned char encodingLoaded[numEncodings];

   605 

   606 static void loadXlfds(const char *reqFamily, int encoding_id)

   607 {

   608     QFontDatabasePrivate *db = privateDb();

   609     QtFontFamily *fontFamily = reqFamily ? db->family(QLatin1String(reqFamily)) : 0;

   610 

   611     // make sure we don't load twice

   612     if ((encoding_id == -1 && xlfdsFullyLoaded)

   613         || (encoding_id != -1 && encodingLoaded[encoding_id]))

   614         return;

   615     if (fontFamily && fontFamily->xlfdLoaded)

   616         return;

   617 

   618     int fontCount;

   619     // force the X server to give us XLFDs

   620     QByteArray xlfd_pattern("-*-");

   621     xlfd_pattern += (reqFamily && reqFamily[0] != '\0') ? reqFamily : "*";

   622     xlfd_pattern += "-*-*-*-*-*-*-*-*-*-*-";

   623     xlfd_pattern += xlfd_for_id(encoding_id);

   624 

   625     char **fontList = XListFonts(QX11Info::display(),

   626                                  xlfd_pattern,

   627                                  0xffff, &fontCount);

   628     // qDebug("requesting xlfd='%s', got %d fonts", xlfd_pattern.data(), fontCount);

   629 

   630 

   631     char *tokens[NFontFields];

   632 

   633     for(int i = 0 ; i < fontCount ; i++) {

   634         if (! parseXFontName(fontList[i], tokens))

   635             continue;

   636 

   637         // get the encoding_id for this xlfd.  we need to do this

   638         // here, since we can pass -1 to this function to do full

   639         // database population

   640         *(tokens[CharsetEncoding] - 1) = '-';

   641         int encoding_id = qt_xlfd_encoding_id(tokens[CharsetRegistry]);

   642         if (encoding_id == -1)

   643             continue;

   644 

   645         char *familyName = tokens[Family];

   646         capitalize(familyName);

   647         char *foundryName = tokens[Foundry];

   648         capitalize(foundryName);

   649         QtFontStyle::Key styleKey = getStyle(tokens);

   650 

   651         bool smooth_scalable = false;

   652         bool bitmap_scalable = false;

   653         if (isScalable(tokens)) {

   654             if (isSmoothlyScalable(tokens))

   655                 smooth_scalable = true;

   656             else

   657                 bitmap_scalable = true;

   658         }

   659         uint pixelSize = atoi(tokens[PixelSize]);

   660         uint xpointSize = atoi(tokens[PointSize]);

   661         uint xres = atoi(tokens[ResolutionX]);

   662         uint yres = atoi(tokens[ResolutionY]);

   663         uint avgwidth = atoi(tokens[AverageWidth]);

   664         bool fixedPitch = isFixedPitch(tokens);

   665 

   666         if (avgwidth == 0 && pixelSize != 0) {

   667             /*

   668               Ignore bitmap scalable fonts that are automatically

   669               generated by some X servers.  We know they are bitmap

   670               scalable because even though they have a specified pixel

   671               size, the average width is zero.

   672             */

   673             continue;

   674         }

   675 

   676         QtFontFamily *family = fontFamily ? fontFamily : db->family(QLatin1String(familyName), true);

   677         family->fontFileIndex = -1;

   678         family->symbol_checked = true;

   679         QtFontFoundry *foundry = family->foundry(QLatin1String(foundryName), true);

   680         QtFontStyle *style = foundry->style(styleKey, true);

   681 

   682         delete [] style->weightName;

   683         style->weightName = qstrdup(tokens[Weight]);

   684         delete [] style->setwidthName;

   685         style->setwidthName = qstrdup(tokens[Width]);

   686 

   687         if (smooth_scalable) {

   688             style->smoothScalable = true;

   689             style->bitmapScalable = false;

   690             pixelSize = SMOOTH_SCALABLE;

   691         }

   692         if (!style->smoothScalable && bitmap_scalable)

   693             style->bitmapScalable = true;

   694         if (!fixedPitch)

   695             family->fixedPitch = false;

   696 

   697         QtFontSize *size = style->pixelSize(pixelSize, true);

   698         QtFontEncoding *enc =

   699             size->encodingID(encoding_id, xpointSize, xres, yres, avgwidth, true);

   700         enc->pitch = *tokens[Spacing];

   701         if (!enc->pitch) enc->pitch = '*';

   702 

   703         for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {

   704             if (writingSystems_for_xlfd_encoding[encoding_id][i])

   705                 family->writingSystems[i] = QtFontFamily::Supported;

   706         }

   707     }

   708     if (!reqFamily) {

   709         // mark encoding as loaded

   710         if (encoding_id == -1)

   711             xlfdsFullyLoaded = true;

   712         else

   713             encodingLoaded[encoding_id] = true;

   714     }

   715 

   716     XFreeFontNames(fontList);

   717 }

   718 

   719 

   720 #ifndef QT_NO_FONTCONFIG

   721 

   722 #ifndef FC_WIDTH

   723 #define FC_WIDTH "width"

   724 #endif

   725 

   726 static int getFCWeight(int fc_weight)

   727 {

   728     int qtweight = QFont::Black;

   729     if (fc_weight <= (FC_WEIGHT_LIGHT + FC_WEIGHT_MEDIUM) / 2)

   730         qtweight = QFont::Light;

   731     else if (fc_weight <= (FC_WEIGHT_MEDIUM + FC_WEIGHT_DEMIBOLD) / 2)

   732         qtweight = QFont::Normal;

   733     else if (fc_weight <= (FC_WEIGHT_DEMIBOLD + FC_WEIGHT_BOLD) / 2)

   734         qtweight = QFont::DemiBold;

   735     else if (fc_weight <= (FC_WEIGHT_BOLD + FC_WEIGHT_BLACK) / 2)

   736         qtweight = QFont::Bold;

   737 

   738     return qtweight;

   739 }

   740 

   741 QFontDef qt_FcPatternToQFontDef(FcPattern *pattern, const QFontDef &request)

   742 {

   743     QFontDef fontDef;

   744     fontDef.styleStrategy = request.styleStrategy;

   745 

   746     FcChar8 *value = 0;

   747     if (FcPatternGetString(pattern, FC_FAMILY, 0, &value) == FcResultMatch) {

   748         fontDef.family = QString::fromUtf8(reinterpret_cast<const char *>(value));

   749     }

   750 

   751     double dpi;

   752     if (FcPatternGetDouble(pattern, FC_DPI, 0, &dpi) != FcResultMatch) {

   753         if (X11->display)

   754             dpi = QX11Info::appDpiY();

   755         else

   756             dpi = qt_defaultDpiY();

   757     }

   758 

   759     double size;

   760     if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &size) == FcResultMatch)

   761         fontDef.pixelSize = size;

   762     else

   763         fontDef.pixelSize = 12;

   764 

   765     fontDef.pointSize = qt_pointSize(fontDef.pixelSize, qRound(dpi));

   766 

   767     /* ###

   768        fontDef.styleHint

   769     */

   770 

   771     int weight;

   772     if (FcPatternGetInteger(pattern, FC_WEIGHT, 0, &weight) != FcResultMatch)

   773         weight = FC_WEIGHT_MEDIUM;

   774     fontDef.weight = getFCWeight(weight);

   775 

   776     int slant;

   777     if (FcPatternGetInteger(pattern, FC_SLANT, 0, &slant) != FcResultMatch)

   778         slant = FC_SLANT_ROMAN;

   779     fontDef.style = (slant == FC_SLANT_ITALIC)

   780                     ? QFont::StyleItalic

   781                     : ((slant == FC_SLANT_OBLIQUE)

   782                        ? QFont::StyleOblique

   783                        : QFont::StyleNormal);

   784 

   785 

   786     FcBool scalable;

   787     if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &scalable) != FcResultMatch)

   788         scalable = false;

   789     if (scalable) {

   790         fontDef.stretch = request.stretch;

   791         fontDef.style = request.style;

   792     } else {

   793         int width;

   794         if (FcPatternGetInteger(pattern, FC_WIDTH, 0, &width) == FcResultMatch)

   795             fontDef.stretch = width;

   796         else

   797             fontDef.stretch = 100;

   798     }

   799 

   800     int spacing;

   801     if (FcPatternGetInteger(pattern, FC_SPACING, 0, &spacing) == FcResultMatch) {

   802         fontDef.fixedPitch = (spacing >= FC_MONO);

   803         fontDef.ignorePitch = false;

   804     } else {

   805         fontDef.ignorePitch = true;

   806     }

   807 

   808     return fontDef;

   809 }

   810 

   811 static const char *specialLanguages[] = {

   812     "en", // Common

   813     "el", // Greek

   814     "ru", // Cyrillic

   815     "hy", // Armenian

   816     "he", // Hebrew

   817     "ar", // Arabic

   818     "syr", // Syriac

   819     "div", // Thaana

   820     "hi", // Devanagari

   821     "bn", // Bengali

   822     "pa", // Gurmukhi

   823     "gu", // Gujarati

   824     "or", // Oriya

   825     "ta", // Tamil

   826     "te", // Telugu

   827     "kn", // Kannada

   828     "ml", // Malayalam

   829     "si", // Sinhala

   830     "th", // Thai

   831     "lo", // Lao

   832     "bo", // Tibetan

   833     "my", // Myanmar

   834     "ka", // Georgian

   835     "ko", // Hangul

   836     "", // Ogham

   837     "", // Runic

   838     "km", // Khmer

   839     "" // N'Ko

   840 };

   841 enum { SpecialLanguageCount = sizeof(specialLanguages) / sizeof(const char *) };

   842 

   843 static const ushort specialChars[] = {

   844     0, // English

   845     0, // Greek

   846     0, // Cyrillic

   847     0, // Armenian

   848     0, // Hebrew

   849     0, // Arabic

   850     0, // Syriac

   851     0, // Thaana

   852     0, // Devanagari

   853     0, // Bengali

   854     0, // Gurmukhi

   855     0, // Gujarati

   856     0, // Oriya

   857     0, // Tamil

   858     0xc15, // Telugu

   859     0xc95, // Kannada

   860     0xd15, // Malayalam

   861     0xd9a, // Sinhala

   862     0, // Thai

   863     0, // Lao

   864     0, // Tibetan

   865     0x1000, // Myanmar

   866     0, // Georgian

   867     0, // Hangul

   868     0x1681, // Ogham

   869     0x16a0, // Runic

   870     0,  // Khmer

   871     0x7ca // N'Ko

   872 };

   873 enum { SpecialCharCount = sizeof(specialChars) / sizeof(ushort) };

   874 

   875 // this could become a list of all languages used for each writing

   876 // system, instead of using the single most common language.

   877 static const char *languageForWritingSystem[] = {

   878     0,     // Any

   879     "en",  // Latin

   880     "el",  // Greek

   881     "ru",  // Cyrillic

   882     "hy",  // Armenian

   883     "he",  // Hebrew

   884     "ar",  // Arabic

   885     "syr", // Syriac

   886     "div", // Thaana

   887     "hi",  // Devanagari

   888     "bn",  // Bengali

   889     "pa",  // Gurmukhi

   890     "gu",  // Gujarati

   891     "or",  // Oriya

   892     "ta",  // Tamil

   893     "te",  // Telugu

   894     "kn",  // Kannada

   895     "ml",  // Malayalam

   896     "si",  // Sinhala

   897     "th",  // Thai

   898     "lo",  // Lao

   899     "bo",  // Tibetan

   900     "my",  // Myanmar

   901     "ka",  // Georgian

   902     "km",  // Khmer

   903     "zh-cn", // SimplifiedChinese

   904     "zh-tw", // TraditionalChinese

   905     "ja",  // Japanese

   906     "ko",  // Korean

   907     "vi",  // Vietnamese

   908     0, // Symbol

   909     0, // Ogham

   910     0, // Runic

   911     0 // N'Ko

   912 };

   913 enum { LanguageCount = sizeof(languageForWritingSystem) / sizeof(const char *) };

   914 

   915 // Unfortunately FontConfig doesn't know about some languages. We have to test these through the

   916 // charset. The lists below contain the systems where we need to do this.

   917 static const ushort sampleCharForWritingSystem[] = {

   918     0,     // Any

   919     0,  // Latin

   920     0,  // Greek

   921     0,  // Cyrillic

   922     0,  // Armenian

   923     0,  // Hebrew

   924     0,  // Arabic

   925     0, // Syriac

   926     0, // Thaana

   927     0,  // Devanagari

   928     0,  // Bengali

   929     0,  // Gurmukhi

   930     0,  // Gujarati

   931     0,  // Oriya

   932     0,  // Tamil

   933     0xc15,  // Telugu

   934     0xc95,  // Kannada

   935     0xd15,  // Malayalam

   936     0xd9a,  // Sinhala

   937     0,  // Thai

   938     0,  // Lao

   939     0,  // Tibetan

   940     0x1000,  // Myanmar

   941     0,  // Georgian

   942     0,  // Khmer

   943     0, // SimplifiedChinese

   944     0, // TraditionalChinese

   945     0,  // Japanese

   946     0,  // Korean

   947     0,  // Vietnamese

   948     0, // Symbol

   949     0x1681, // Ogham

   950     0x16a0, // Runic

   951     0x7ca // N'Ko

   952 };

   953 enum { SampleCharCount = sizeof(sampleCharForWritingSystem) / sizeof(ushort) };

   954 

   955 // Newer FontConfig let's us sort out fonts that contain certain glyphs, but no

   956 // open type tables for is directly. Do this so we don't pick some strange

   957 // pseudo unicode font

   958 static const char *openType[] = {

   959     0,     // Any

   960     0,  // Latin

   961     0,  // Greek

   962     0,  // Cyrillic

   963     0,  // Armenian

   964     0,  // Hebrew

   965     0,  // Arabic

   966     "syrc",  // Syriac

   967     "thaa",  // Thaana

   968     "deva",  // Devanagari

   969     "beng",  // Bengali

   970     "guru",  // Gurmukhi

   971     "gurj",  // Gujarati

   972     "orya",  // Oriya

   973     "taml",  // Tamil

   974     "telu",  // Telugu

   975     "knda",  // Kannada

   976     "mlym",  // Malayalam

   977     "sinh",  // Sinhala

   978     0,  // Thai

   979     0,  // Lao

   980     "tibt",  // Tibetan

   981     "mymr",  // Myanmar

   982     0,  // Georgian

   983     "khmr",  // Khmer

   984     0, // SimplifiedChinese

   985     0, // TraditionalChinese

   986     0,  // Japanese

   987     0,  // Korean

   988     0,  // Vietnamese

   989     0, // Symbol

   990     0, // Ogham

   991     0, // Runic

   992     "nko " // N'Ko

   993 };

   994 enum { OpenTypeCount = sizeof(openType) / sizeof(const char *) };

   995 

   996 

   997 static void loadFontConfig()

   998 {

   999     Q_ASSERT_X(X11, "QFontDatabase",

  1000                "A QApplication object needs to be constructed before FontConfig is used.");

  1001     if (!X11->has_fontconfig)

  1002         return;

  1003 

  1004     Q_ASSERT_X(int(QUnicodeTables::ScriptCount) == SpecialLanguageCount,

  1005                "QFontDatabase", "New scripts have been added.");

  1006     Q_ASSERT_X(int(QUnicodeTables::ScriptCount) == SpecialCharCount,

  1007                "QFontDatabase", "New scripts have been added.");

  1008     Q_ASSERT_X(int(QFontDatabase::WritingSystemsCount) == LanguageCount,

  1009                "QFontDatabase", "New writing systems have been added.");

  1010     Q_ASSERT_X(int(QFontDatabase::WritingSystemsCount) == SampleCharCount,

  1011                "QFontDatabase", "New writing systems have been added.");

  1012     Q_ASSERT_X(int(QFontDatabase::WritingSystemsCount) == OpenTypeCount,

  1013                "QFontDatabase", "New writing systems have been added.");

  1014 

  1015     QFontDatabasePrivate *db = privateDb();

  1016     FcFontSet  *fonts;

  1017 

  1018     QString familyName;

  1019     FcChar8 *value = 0;

  1020     int weight_value;

  1021     int slant_value;

  1022     int spacing_value;

  1023     FcChar8 *file_value;

  1024     int index_value;

  1025     FcChar8 *foundry_value;

  1026     FcBool scalable;

  1027 

  1028     {

  1029         FcObjectSet *os = FcObjectSetCreate();

  1030         FcPattern *pattern = FcPatternCreate();

  1031         const char *properties [] = {

  1032             FC_FAMILY, FC_WEIGHT, FC_SLANT,

  1033             FC_SPACING, FC_FILE, FC_INDEX,

  1034             FC_LANG, FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE, FC_WEIGHT,

  1035             FC_WIDTH,

  1036 #if FC_VERSION >= 20297

  1037             FC_CAPABILITY,

  1038 #endif

  1039             (const char *)0

  1040         };

  1041         const char **p = properties;

  1042         while (*p) {

  1043             FcObjectSetAdd(os, *p);

  1044             ++p;

  1045         }

  1046         fonts = FcFontList(0, pattern, os);

  1047         FcObjectSetDestroy(os);

  1048         FcPatternDestroy(pattern);

  1049     }

  1050 

  1051     for (int i = 0; i < fonts->nfont; i++) {

  1052         if (FcPatternGetString(fonts->fonts[i], FC_FAMILY, 0, &value) != FcResultMatch)

  1053             continue;

  1054         //         capitalize(value);

  1055         familyName = QString::fromUtf8((const char *)value);

  1056         slant_value = FC_SLANT_ROMAN;

  1057         weight_value = FC_WEIGHT_MEDIUM;

  1058         spacing_value = FC_PROPORTIONAL;

  1059 	file_value = 0;

  1060 	index_value = 0;

  1061 	scalable = FcTrue;

  1062 

  1063         if (FcPatternGetInteger (fonts->fonts[i], FC_SLANT, 0, &slant_value) != FcResultMatch)

  1064 	    slant_value = FC_SLANT_ROMAN;

  1065         if (FcPatternGetInteger (fonts->fonts[i], FC_WEIGHT, 0, &weight_value) != FcResultMatch)

  1066 	    weight_value = FC_WEIGHT_MEDIUM;

  1067         if (FcPatternGetInteger (fonts->fonts[i], FC_SPACING, 0, &spacing_value) != FcResultMatch)

  1068 	    spacing_value = FC_PROPORTIONAL;

  1069         if (FcPatternGetString (fonts->fonts[i], FC_FILE, 0, &file_value) != FcResultMatch)

  1070 	    file_value = 0;

  1071         if (FcPatternGetInteger (fonts->fonts[i], FC_INDEX, 0, &index_value) != FcResultMatch)

  1072 	    index_value = 0;

  1073         if (FcPatternGetBool(fonts->fonts[i], FC_SCALABLE, 0, &scalable) != FcResultMatch)

  1074 	    scalable = FcTrue;

  1075         if (FcPatternGetString(fonts->fonts[i], FC_FOUNDRY, 0, &foundry_value) != FcResultMatch)

  1076 	    foundry_value = 0;

  1077         QtFontFamily *family = db->family(familyName, true);

  1078 

  1079         FcLangSet *langset = 0;

  1080         FcResult res = FcPatternGetLangSet(fonts->fonts[i], FC_LANG, 0, &langset);

  1081         if (res == FcResultMatch) {

  1082             for (int i = 1; i < LanguageCount; ++i) {

  1083                 const FcChar8 *lang = (const FcChar8*) languageForWritingSystem[i];

  1084                 if (!lang) {

  1085                     family->writingSystems[i] |= QtFontFamily::UnsupportedFT;

  1086                 } else {

  1087                     FcLangResult langRes = FcLangSetHasLang(langset, lang);

  1088                     if (langRes != FcLangDifferentLang)

  1089                         family->writingSystems[i] = QtFontFamily::Supported;

  1090                     else

  1091                         family->writingSystems[i] |= QtFontFamily::UnsupportedFT;

  1092                 }

  1093             }

  1094             family->writingSystems[QFontDatabase::Other] = QtFontFamily::UnsupportedFT;

  1095             family->ftWritingSystemCheck = true;

  1096         } else {

  1097             // we set Other to supported for symbol fonts. It makes no

  1098             // sense to merge these with other ones, as they are

  1099             // special in a way.

  1100             for (int i = 1; i < LanguageCount; ++i)

  1101                 family->writingSystems[i] |= QtFontFamily::UnsupportedFT;

  1102             family->writingSystems[QFontDatabase::Other] = QtFontFamily::Supported;

  1103         }

  1104 

  1105         FcCharSet *cs = 0;

  1106         res = FcPatternGetCharSet(fonts->fonts[i], FC_CHARSET, 0, &cs);

  1107         if (res == FcResultMatch) {

  1108             // some languages are not supported by FontConfig, we rather check the

  1109             // charset to detect these

  1110             for (int i = 1; i < SampleCharCount; ++i) {

  1111                 if (!sampleCharForWritingSystem[i])

  1112                     continue;

  1113                 if (FcCharSetHasChar(cs, sampleCharForWritingSystem[i]))

  1114                     family->writingSystems[i] = QtFontFamily::Supported;

  1115             }

  1116         }

  1117 

  1118 #if FC_VERSION >= 20297

  1119         for (int j = 1; j < LanguageCount; ++j) {

  1120             if (family->writingSystems[j] == QtFontFamily::Supported && requiresOpenType(j) && openType[j]) {

  1121                 FcChar8 *cap;

  1122                 res = FcPatternGetString (fonts->fonts[i], FC_CAPABILITY, 0, &cap);

  1123                 if (res != FcResultMatch || !strstr((const char *)cap, openType[j]))

  1124                     family->writingSystems[j] = QtFontFamily::UnsupportedFT;

  1125             }

  1126         }

  1127 #endif

  1128 

  1129         QByteArray file((const char *)file_value);

  1130         family->fontFilename = file;

  1131         family->fontFileIndex = index_value;

  1132 

  1133         QtFontStyle::Key styleKey;

  1134         styleKey.style = (slant_value == FC_SLANT_ITALIC)

  1135                          ? QFont::StyleItalic