1 /****************************************************************************
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
7 ** This file is part of the QtGui module of the Qt Toolkit.
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
40 ****************************************************************************/
42 #include <qplatformdefs.h>
45 #include <qpaintdevice.h>
46 #include <qelapsedtimer.h>
48 #include <private/qt_x11_p.h>
49 #include "qx11info_x11.h"
52 #include <qtemporaryfile.h>
53 #include <qabstractfileengine.h>
59 #include <sys/types.h>
64 #include <private/qfontengine_x11_p.h>
66 #ifndef QT_NO_FONTCONFIG
68 #include FT_FREETYPE_H
70 #if FC_VERSION >= 20402
71 #include <fontconfig/fcfreetype.h>
78 extern double qt_pointSize(double pixelSize, int dpi);
79 extern double qt_pixelSize(double pointSize, int dpi);
81 // from qapplication.cpp
82 extern bool qt_is_gui_used;
84 static inline void capitalize (char *s)
97 To regenerate the writingSystems_for_xlfd_encoding table, run
98 'util/unicode/x11/makeencodings' and paste the generated
101 // ----- begin of generated code -----
103 #define make_tag( c1, c2, c3, c4 ) \
104 ((((unsigned int)c1)<<24) | (((unsigned int)c2)<<16) | \
105 (((unsigned int)c3)<<8) | ((unsigned int)c4))
107 struct XlfdEncoding {
115 static const XlfdEncoding xlfd_encoding[] = {
116 { "iso8859-1", 0, 4, make_tag('i','s','o','8'), make_tag('5','9','-','1') },
117 { "iso8859-2", 1, 5, make_tag('i','s','o','8'), make_tag('5','9','-','2') },
118 { "iso8859-3", 2, 6, make_tag('i','s','o','8'), make_tag('5','9','-','3') },
119 { "iso8859-4", 3, 7, make_tag('i','s','o','8'), make_tag('5','9','-','4') },
120 { "iso8859-9", 4, 12, make_tag('i','s','o','8'), make_tag('5','9','-','9') },
121 { "iso8859-10", 5, 13, make_tag('i','s','o','8'), make_tag('9','-','1','0') },
122 { "iso8859-13", 6, 109, make_tag('i','s','o','8'), make_tag('9','-','1','3') },
123 { "iso8859-14", 7, 110, make_tag('i','s','o','8'), make_tag('9','-','1','4') },
124 { "iso8859-15", 8, 111, make_tag('i','s','o','8'), make_tag('9','-','1','5') },
125 { "hp-roman8", 9, 2004, make_tag('h','p','-','r'), make_tag('m','a','n','8') },
126 { "iso8859-5", 10, 8, make_tag('i','s','o','8'), make_tag('5','9','-','5') },
127 { "*-cp1251", 11, 2251, 0, make_tag('1','2','5','1') },
128 { "koi8-ru", 12, 2084, make_tag('k','o','i','8'), make_tag('8','-','r','u') },
129 { "koi8-u", 13, 2088, make_tag('k','o','i','8'), make_tag('i','8','-','u') },
130 { "koi8-r", 14, 2084, make_tag('k','o','i','8'), make_tag('i','8','-','r') },
131 { "iso8859-7", 15, 10, make_tag('i','s','o','8'), make_tag('5','9','-','7') },
132 { "iso8859-8", 16, 85, make_tag('i','s','o','8'), make_tag('5','9','-','8') },
133 { "gb18030-0", 17, -114, make_tag('g','b','1','8'), make_tag('3','0','-','0') },
134 { "gb18030.2000-0", 18, -113, make_tag('g','b','1','8'), make_tag('0','0','-','0') },
135 { "gbk-0", 19, -113, make_tag('g','b','k','-'), make_tag('b','k','-','0') },
136 { "gb2312.*-0", 20, 57, make_tag('g','b','2','3'), 0 },
137 { "jisx0201*-0", 21, 15, make_tag('j','i','s','x'), 0 },
138 { "jisx0208*-0", 22, 63, make_tag('j','i','s','x'), 0 },
139 { "ksc5601*-*", 23, 36, make_tag('k','s','c','5'), 0 },
140 { "big5hkscs-0", 24, -2101, make_tag('b','i','g','5'), make_tag('c','s','-','0') },
141 { "hkscs-1", 25, -2101, make_tag('h','k','s','c'), make_tag('c','s','-','1') },
142 { "big5*-*", 26, -2026, make_tag('b','i','g','5'), 0 },
143 { "tscii-*", 27, 2028, make_tag('t','s','c','i'), 0 },
144 { "tis620*-*", 28, 2259, make_tag('t','i','s','6'), 0 },
145 { "iso8859-11", 29, 2259, make_tag('i','s','o','8'), make_tag('9','-','1','1') },
146 { "mulelao-1", 30, -4242, make_tag('m','u','l','e'), make_tag('a','o','-','1') },
147 { "ethiopic-unicode", 31, 0, make_tag('e','t','h','i'), make_tag('c','o','d','e') },
148 { "iso10646-1", 32, 0, make_tag('i','s','o','1'), make_tag('4','6','-','1') },
149 { "unicode-*", 33, 0, make_tag('u','n','i','c'), 0 },
150 { "*-symbol", 34, 0, 0, make_tag('m','b','o','l') },
151 { "*-fontspecific", 35, 0, 0, make_tag('i','f','i','c') },
152 { "fontspecific-*", 36, 0, make_tag('f','o','n','t'), 0 },
156 static const char writingSystems_for_xlfd_encoding[sizeof(xlfd_encoding)][QFontDatabase::WritingSystemsCount] = {
158 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
159 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
160 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
163 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
164 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
165 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
168 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
169 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
170 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
173 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
174 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
175 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
178 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
179 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
180 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
183 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
184 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
185 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
188 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
189 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
190 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
193 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
194 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
195 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
198 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
199 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
200 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
203 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
204 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
205 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
208 { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
209 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
210 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
213 { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
218 { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
223 { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
228 { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
229 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
230 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
233 { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
234 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
238 { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
248 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
253 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
258 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
263 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
265 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
268 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
270 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
273 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
274 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
275 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
278 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
280 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
283 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
284 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
285 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
288 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
289 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
290 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
293 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
294 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
295 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
298 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
299 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
300 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
303 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
304 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
305 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
308 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
309 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
310 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
313 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
314 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
318 { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
319 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
320 1, 1, 0, 1, 0, 1, 1, 0, 0, 0,
323 { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
324 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
325 1, 1, 0, 1, 0, 1, 1, 0, 0, 0,
328 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
329 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
330 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
333 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
334 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
335 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
338 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
339 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
340 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
345 // ----- end of generated code -----
348 const int numEncodings = sizeof(xlfd_encoding) / sizeof(XlfdEncoding) - 1;
350 int qt_xlfd_encoding_id(const char *encoding)
352 // qDebug("looking for encoding id for '%s'", encoding);
353 int len = strlen(encoding);
356 unsigned int hash1 = make_tag(encoding[0], encoding[1], encoding[2], encoding[3]);
357 const char *ch = encoding + len - 4;
358 unsigned int hash2 = make_tag(ch[0], ch[1], ch[2], ch[3]);
360 const XlfdEncoding *enc = xlfd_encoding;
361 for (; enc->name; ++enc) {
362 if ((enc->hash1 && enc->hash1 != hash1) ||
363 (enc->hash2 && enc->hash2 != hash2))
365 // hashes match, do a compare if strings match
366 // the enc->name can contain '*'s we have to interpret correctly
367 const char *n = enc->name;
368 const char *e = encoding;
370 // qDebug("bol: *e='%c', *n='%c'", *e, *n);
374 // qDebug("found encoding id %d", enc->id);
385 // qDebug("skip: *e='%c', *n='%c'", *e, *n);
386 while (*e && *e != *n)
390 // qDebug("couldn't find encoding %s", encoding);
394 int qt_mib_for_xlfd_encoding(const char *encoding)
396 int id = qt_xlfd_encoding_id(encoding);
397 if (id != -1) return xlfd_encoding[id].mib;
401 int qt_encoding_id_for_mib(int mib)
403 const XlfdEncoding *enc = xlfd_encoding;
404 for (; enc->name; ++enc) {
411 static const char * xlfd_for_id(int id)
413 // special case: -1 returns the "*-*" encoding, allowing us to do full
414 // database population in a single X server round trip.
415 if (id < 0 || id > numEncodings)
417 return xlfd_encoding[id].name;
420 enum XLFDFieldNames {
438 // Splits an X font name into fields separated by '-'
439 static bool parseXFontName(char *fontName, char **tokens)
441 if (! fontName || fontName[0] == '0' || fontName[0] != '-') {
448 for (i = 0; i < NFontFields && fontName && fontName[0]; ++i) {
449 tokens[i] = fontName;
450 for (;; ++fontName) {
451 if (*fontName == '-')
459 if (fontName) *fontName++ = '\0';
462 if (i < NFontFields) {
463 for (int j = i ; j < NFontFields; ++j)
471 static inline bool isZero(char *x)
473 return (x[0] == '0' && x[1] == 0);
476 static inline bool isScalable(char **tokens)
478 return (isZero(tokens[PixelSize]) &&
479 isZero(tokens[PointSize]) &&
480 isZero(tokens[AverageWidth]));
483 static inline bool isSmoothlyScalable(char **tokens)
485 return (isZero(tokens[ResolutionX]) &&
486 isZero(tokens[ResolutionY]));
489 static inline bool isFixedPitch(char **tokens)
491 return (tokens[Spacing][0] == 'm' ||
492 tokens[Spacing][0] == 'c' ||
493 tokens[Spacing][0] == 'M' ||
494 tokens[Spacing][0] == 'C');
498 Fills in a font definition (QFontDef) from an XLFD (X Logical Font
501 Returns true if the given xlfd is valid.
503 bool qt_fillFontDef(const QByteArray &xlfd, QFontDef *fd, int dpi, QtFontDesc *desc)
505 char *tokens[NFontFields];
506 QByteArray buffer = xlfd;
507 if (! parseXFontName(buffer.data(), tokens))
510 capitalize(tokens[Family]);
511 capitalize(tokens[Foundry]);
513 fd->styleStrategy |= QFont::NoAntialias;
514 fd->family = QString::fromLatin1(tokens[Family]);
515 QString foundry = QString::fromLatin1(tokens[Foundry]);
516 if (! foundry.isEmpty() && foundry != QLatin1String("*") && (!desc || desc->family->count > 1))
518 QLatin1String(" [") + foundry + QLatin1Char(']');
520 if (qstrlen(tokens[AddStyle]) > 0)
521 fd->addStyle = QString::fromLatin1(tokens[AddStyle]);
523 fd->addStyle.clear();
525 fd->pointSize = atoi(tokens[PointSize])/10.;
526 fd->styleHint = QFont::AnyStyle; // ### any until we match families
528 char slant = tolower((uchar) tokens[Slant][0]);
529 fd->style = (slant == 'o' ? QFont::StyleOblique : (slant == 'i' ? QFont::StyleItalic : QFont::StyleNormal));
530 char fixed = tolower((uchar) tokens[Spacing][0]);
531 fd->fixedPitch = (fixed == 'm' || fixed == 'c');
532 fd->weight = getFontWeight(QLatin1String(tokens[Weight]));
534 int r = atoi(tokens[ResolutionY]);
535 fd->pixelSize = atoi(tokens[PixelSize]);
536 // not "0" or "*", or required DPI
537 if (r && fd->pixelSize && r != dpi) {
538 // calculate actual pointsize for display DPI
539 fd->pointSize = qt_pointSize(fd->pixelSize, dpi);
540 } else if (fd->pixelSize == 0 && fd->pointSize) {
541 // calculate pixel size from pointsize/dpi
542 fd->pixelSize = qRound(qt_pixelSize(fd->pointSize, dpi));
549 Fills in a font definition (QFontDef) from the font properties in an
552 Returns true if the QFontDef could be filled with properties from
555 static bool qt_fillFontDef(XFontStruct *fs, QFontDef *fd, int dpi, QtFontDesc *desc)
558 if (!fs || !XGetFontProperty(fs, XA_FONT, &value))
561 char *n = XGetAtomName(QX11Info::display(), value);
565 return qt_fillFontDef(xlfd.toLower(), fd, dpi, desc);
569 static QtFontStyle::Key getStyle(char ** tokens)
571 QtFontStyle::Key key;
573 char slant0 = tolower((uchar) tokens[Slant][0]);
576 if (tokens[Slant][1]) {
577 char slant1 = tolower((uchar) tokens[Slant][1]);
580 key.style = QFont::StyleOblique;
581 else if (slant1 == 'i')
582 key.style = QFont::StyleItalic;
584 } else if (slant0 == 'o')
585 key.style = QFont::StyleOblique;
586 else if (slant0 == 'i')
587 key.style = QFont::StyleItalic;
589 key.weight = getFontWeight(QLatin1String(tokens[Weight]));
591 if (qstrcmp(tokens[Width], "normal") == 0) {
593 } else if (qstrcmp(tokens[Width], "semi condensed") == 0 ||
594 qstrcmp(tokens[Width], "semicondensed") == 0) {
596 } else if (qstrcmp(tokens[Width], "condensed") == 0) {
598 } else if (qstrcmp(tokens[Width], "narrow") == 0) {
606 static bool xlfdsFullyLoaded = false;
607 static unsigned char encodingLoaded[numEncodings];
609 static void loadXlfds(const char *reqFamily, int encoding_id)
611 QFontDatabasePrivate *db = privateDb();
612 QtFontFamily *fontFamily = reqFamily ? db->family(QLatin1String(reqFamily)) : 0;
614 // make sure we don't load twice
615 if ((encoding_id == -1 && xlfdsFullyLoaded)
616 || (encoding_id != -1 && encodingLoaded[encoding_id]))
618 if (fontFamily && fontFamily->xlfdLoaded)
622 // force the X server to give us XLFDs
623 QByteArray xlfd_pattern("-*-");
624 xlfd_pattern += (reqFamily && reqFamily[0] != '\0') ? reqFamily : "*";
625 xlfd_pattern += "-*-*-*-*-*-*-*-*-*-*-";
626 xlfd_pattern += xlfd_for_id(encoding_id);
628 char **fontList = XListFonts(QX11Info::display(),
631 // qDebug("requesting xlfd='%s', got %d fonts", xlfd_pattern.data(), fontCount);
634 char *tokens[NFontFields];
636 for(int i = 0 ; i < fontCount ; i++) {
637 if (! parseXFontName(fontList[i], tokens))
640 // get the encoding_id for this xlfd. we need to do this
641 // here, since we can pass -1 to this function to do full
642 // database population
643 *(tokens[CharsetEncoding] - 1) = '-';
644 int encoding_id = qt_xlfd_encoding_id(tokens[CharsetRegistry]);
645 if (encoding_id == -1)
648 char *familyName = tokens[Family];
649 capitalize(familyName);
650 char *foundryName = tokens[Foundry];
651 capitalize(foundryName);
652 QtFontStyle::Key styleKey = getStyle(tokens);
654 bool smooth_scalable = false;
655 bool bitmap_scalable = false;
656 if (isScalable(tokens)) {
657 if (isSmoothlyScalable(tokens))
658 smooth_scalable = true;
660 bitmap_scalable = true;
662 uint pixelSize = atoi(tokens[PixelSize]);
663 uint xpointSize = atoi(tokens[PointSize]);
664 uint xres = atoi(tokens[ResolutionX]);
665 uint yres = atoi(tokens[ResolutionY]);
666 uint avgwidth = atoi(tokens[AverageWidth]);
667 bool fixedPitch = isFixedPitch(tokens);
669 if (avgwidth == 0 && pixelSize != 0) {
671 Ignore bitmap scalable fonts that are automatically
672 generated by some X servers. We know they are bitmap
673 scalable because even though they have a specified pixel
674 size, the average width is zero.
679 QtFontFamily *family = fontFamily ? fontFamily : db->family(QLatin1String(familyName), true);
680 family->fontFileIndex = -1;
681 family->symbol_checked = true;
682 QtFontFoundry *foundry = family->foundry(QLatin1String(foundryName), true);
683 QtFontStyle *style = foundry->style(styleKey, true);
685 delete [] style->weightName;
686 style->weightName = qstrdup(tokens[Weight]);
687 delete [] style->setwidthName;
688 style->setwidthName = qstrdup(tokens[Width]);
690 if (smooth_scalable) {
691 style->smoothScalable = true;
692 style->bitmapScalable = false;
693 pixelSize = SMOOTH_SCALABLE;
695 if (!style->smoothScalable && bitmap_scalable)
696 style->bitmapScalable = true;
698 family->fixedPitch = false;
700 QtFontSize *size = style->pixelSize(pixelSize, true);
701 QtFontEncoding *enc =
702 size->encodingID(encoding_id, xpointSize, xres, yres, avgwidth, true);
703 enc->pitch = *tokens[Spacing];
704 if (!enc->pitch) enc->pitch = '*';
706 for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
707 if (writingSystems_for_xlfd_encoding[encoding_id][i])
708 family->writingSystems[i] = QtFontFamily::Supported;
712 // mark encoding as loaded
713 if (encoding_id == -1)
714 xlfdsFullyLoaded = true;
716 encodingLoaded[encoding_id] = true;
719 XFreeFontNames(fontList);
723 #ifndef QT_NO_FONTCONFIG
726 #define FC_WIDTH "width"
729 static int getFCWeight(int fc_weight)
731 int qtweight = QFont::Black;
732 if (fc_weight <= (FC_WEIGHT_LIGHT + FC_WEIGHT_MEDIUM) / 2)
733 qtweight = QFont::Light;
734 else if (fc_weight <= (FC_WEIGHT_MEDIUM + FC_WEIGHT_DEMIBOLD) / 2)
735 qtweight = QFont::Normal;
736 else if (fc_weight <= (FC_WEIGHT_DEMIBOLD + FC_WEIGHT_BOLD) / 2)
737 qtweight = QFont::DemiBold;
738 else if (fc_weight <= (FC_WEIGHT_BOLD + FC_WEIGHT_BLACK) / 2)
739 qtweight = QFont::Bold;
744 QFontDef qt_FcPatternToQFontDef(FcPattern *pattern, const QFontDef &request)
747 fontDef.styleStrategy = request.styleStrategy;
749 fontDef.hintingPreference = request.hintingPreference;
751 if (FcPatternGetString(pattern, FC_FAMILY, 0, &value) == FcResultMatch) {
752 fontDef.family = QString::fromUtf8(reinterpret_cast<const char *>(value));
756 if (FcPatternGetDouble(pattern, FC_DPI, 0, &dpi) != FcResultMatch) {
758 dpi = QX11Info::appDpiY();
760 dpi = qt_defaultDpiY();
764 if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &size) == FcResultMatch)
765 fontDef.pixelSize = size;
767 fontDef.pixelSize = 12;
769 fontDef.pointSize = qt_pointSize(fontDef.pixelSize, qRound(dpi));
776 if (FcPatternGetInteger(pattern, FC_WEIGHT, 0, &weight) != FcResultMatch)
777 weight = FC_WEIGHT_MEDIUM;
778 fontDef.weight = getFCWeight(weight);
781 if (FcPatternGetInteger(pattern, FC_SLANT, 0, &slant) != FcResultMatch)
782 slant = FC_SLANT_ROMAN;
783 fontDef.style = (slant == FC_SLANT_ITALIC)
785 : ((slant == FC_SLANT_OBLIQUE)
786 ? QFont::StyleOblique
787 : QFont::StyleNormal);
791 if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &scalable) != FcResultMatch)
794 fontDef.stretch = request.stretch;
795 fontDef.style = request.style;
798 if (FcPatternGetInteger(pattern, FC_WIDTH, 0, &width) == FcResultMatch)
799 fontDef.stretch = width;
801 fontDef.stretch = 100;
805 if (FcPatternGetInteger(pattern, FC_SPACING, 0, &spacing) == FcResultMatch) {
806 fontDef.fixedPitch = (spacing >= FC_MONO);
807 fontDef.ignorePitch = false;
809 fontDef.ignorePitch = true;
815 static const char *specialLanguages[] = {
845 enum { SpecialLanguageCount = sizeof(specialLanguages) / sizeof(const char *) };
847 static const ushort specialChars[] = {
877 enum { SpecialCharCount = sizeof(specialChars) / sizeof(ushort) };
879 // this could become a list of all languages used for each writing
880 // system, instead of using the single most common language.
881 static const char *languageForWritingSystem[] = {
907 "zh-cn", // SimplifiedChinese
908 "zh-tw", // TraditionalChinese
917 enum { LanguageCount = sizeof(languageForWritingSystem) / sizeof(const char *) };
919 // Unfortunately FontConfig doesn't know about some languages. We have to test these through the
920 // charset. The lists below contain the systems where we need to do this.
921 static const ushort sampleCharForWritingSystem[] = {
947 0, // SimplifiedChinese
948 0, // TraditionalChinese
957 enum { SampleCharCount = sizeof(sampleCharForWritingSystem) / sizeof(ushort) };
959 // Newer FontConfig let's us sort out fonts that contain certain glyphs, but no
960 // open type tables for is directly. Do this so we don't pick some strange
961 // pseudo unicode font
962 static const char *openType[] = {
972 "deva", // Devanagari
988 0, // SimplifiedChinese
989 0, // TraditionalChinese
998 enum { OpenTypeCount = sizeof(openType) / sizeof(const char *) };
1001 static void loadFontConfig()
1003 Q_ASSERT_X(X11, "QFontDatabase",
1004 "A QApplication object needs to be constructed before FontConfig is used.");
1005 if (!X11->has_fontconfig)
1008 Q_ASSERT_X(int(QUnicodeTables::ScriptCount) == SpecialLanguageCount,
1009 "QFontDatabase", "New scripts have been added.");
1010 Q_ASSERT_X(int(QUnicodeTables::ScriptCount) == SpecialCharCount,
1011 "QFontDatabase", "New scripts have been added.");
1012 Q_ASSERT_X(int(QFontDatabase::WritingSystemsCount) == LanguageCount,
1013 "QFontDatabase", "New writing systems have been added.");
1014 Q_ASSERT_X(int(QFontDatabase::WritingSystemsCount) == SampleCharCount,
1015 "QFontDatabase", "New writing systems have been added.");
1016 Q_ASSERT_X(int(QFontDatabase::WritingSystemsCount) == OpenTypeCount,
1017 "QFontDatabase", "New writing systems have been added.");
1019 QFontDatabasePrivate *db = privateDb();
1022 FcPattern *pattern = FcPatternCreate();
1023 FcDefaultSubstitute(pattern);
1025 if (FcPatternGetString(pattern, FC_LANG, 0, &lang) == FcResultMatch)
1026 db->systemLang = QString::fromUtf8((const char *) lang);
1027 FcPatternDestroy(pattern);
1034 FcChar8 *file_value;
1036 FcChar8 *foundry_value;
1037 FcChar8 *style_value;
1041 FcObjectSet *os = FcObjectSetCreate();
1042 FcPattern *pattern = FcPatternCreate();
1043 const char *properties [] = {
1044 FC_FAMILY, FC_STYLE, FC_WEIGHT, FC_SLANT,
1045 FC_SPACING, FC_FILE, FC_INDEX,
1046 FC_LANG, FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE, FC_WEIGHT,
1048 #if FC_VERSION >= 20297
1053 const char **p = properties;
1055 FcObjectSetAdd(os, *p);
1058 fonts = FcFontList(0, pattern, os);
1059 FcObjectSetDestroy(os);
1060 FcPatternDestroy(pattern);
1063 for (int i = 0; i < fonts->nfont; i++) {
1064 if (FcPatternGetString(fonts->fonts[i], FC_FAMILY, 0, &value) != FcResultMatch)
1066 // capitalize(value);
1067 familyName = QString::fromUtf8((const char *)value);
1068 slant_value = FC_SLANT_ROMAN;
1069 weight_value = FC_WEIGHT_MEDIUM;
1070 spacing_value = FC_PROPORTIONAL;
1075 if (FcPatternGetInteger (fonts->fonts[i], FC_SLANT, 0, &slant_value) != FcResultMatch)
1076 slant_value = FC_SLANT_ROMAN;
1077 if (FcPatternGetInteger (fonts->fonts[i], FC_WEIGHT, 0, &weight_value) != FcResultMatch)
1078 weight_value = FC_WEIGHT_MEDIUM;
1079 if (FcPatternGetInteger (fonts->fonts[i], FC_SPACING, 0, &spacing_value) != FcResultMatch)
1080 spacing_value = FC_PROPORTIONAL;
1081 if (FcPatternGetString (fonts->fonts[i], FC_FILE, 0, &file_value) != FcResultMatch)
1083 if (FcPatternGetInteger (fonts->fonts[i], FC_INDEX, 0, &index_value) != FcResultMatch)
1085 if (FcPatternGetBool(fonts->fonts[i], FC_SCALABLE, 0, &scalable) != FcResultMatch)
1087 if (FcPatternGetString(fonts->fonts[i], FC_FOUNDRY, 0, &foundry_value) != FcResultMatch)
1089 if (FcPatternGetString(fonts->fonts[i], FC_STYLE, 0, &style_value) != FcResultMatch)
1091 QtFontFamily *family = db->family(familyName, true);
1093 FcLangSet *langset = 0;
1094 FcResult res = FcPatternGetLangSet(fonts->fonts[i], FC_LANG, 0, &langset);
1095 if (res == FcResultMatch) {
1096 for (int i = 1; i < LanguageCount; ++i) {
1097 const FcChar8 *lang = (const FcChar8*) languageForWritingSystem[i];
1099 family->writingSystems[i] |= QtFontFamily::UnsupportedFT;
1101 FcLangResult langRes = FcLangSetHasLang(langset, lang);
1102 if (langRes != FcLangDifferentLang)
1103 family->writingSystems[i] = QtFontFamily::Supported;
1105 family->writingSystems[i] |= QtFontFamily::UnsupportedFT;
1108 family->writingSystems[QFontDatabase::Other] = QtFontFamily::UnsupportedFT;
1109 family->ftWritingSystemCheck = true;
1111 // we set Other to supported for symbol fonts. It makes no
1112 // sense to merge these with other ones, as they are
1113 // special in a way.
1114 for (int i = 1; i < LanguageCount; ++i)
1115 family->writingSystems[i] |= QtFontFamily::UnsupportedFT;
1116 family->writingSystems[QFontDatabase::Other] = QtFontFamily::Supported;
1120 res = FcPatternGetCharSet(fonts->fonts[i], FC_CHARSET, 0, &cs);
1121 if (res == FcResultMatch) {
1122 // some languages are not supported by FontConfig, we rather check the
1123 // charset to detect these
1124 for (int i = 1; i < SampleCharCount; ++i) {
1125 if (!sampleCharForWritingSystem[i])
1127 if (FcCharSetHasChar(cs, sampleCharForWritingSystem[i]))
1128 family->writingSystems[i] = QtFontFamily::Supported;
1132 #if FC_VERSION >= 20297
1133 for (int j = 1; j < LanguageCount; ++j) {
1134 if (family->writingSystems[j] == QtFontFamily::Supported && requiresOpenType(j) && openType[j]) {
1136 res = FcPatternGetString (fonts->fonts[i], FC_CAPABILITY, 0, &cap);
1137 if (res != FcResultMatch || !strstr((const char *)cap, openType[j]))
1138 family->writingSystems[j] = QtFontFamily::UnsupportedFT;
1143 QByteArray file((const char *)file_value);
1144 family->fontFilename = file;
1145 family->fontFileIndex = index_value;
1147 QtFontStyle::Key styleKey;
1148 styleKey.styleName = style_value ? QString::fromUtf8((const char *) style_value) : QString();
1149 styleKey.style = (slant_value == FC_SLANT_ITALIC)
1150 ? QFont::StyleItalic
1151 : ((slant_value == FC_SLANT_OBLIQUE)
1152 ? QFont::StyleOblique
1153 : QFont::StyleNormal);
1154 styleKey.weight = getFCWeight(weight_value);
1157 FcPatternGetInteger (fonts->fonts[i], FC_WIDTH, 0, &width);
1158 styleKey.stretch = width;
1161 QtFontFoundry *foundry
1162 = family->foundry(foundry_value ? QString::fromUtf8((const char *)foundry_value) : QString(), true);
1163 QtFontStyle *style = foundry->style(styleKey, true);
1165 if (spacing_value < FC_MONO)
1166 family->fixedPitch = false;
1170 style->smoothScalable = true;
1171 size = style->pixelSize(SMOOTH_SCALABLE, true);
1173 double pixel_size = 0;
1174 FcPatternGetDouble (fonts->fonts[i], FC_PIXEL_SIZE, 0, &pixel_size);
1175 size = style->pixelSize((int)pixel_size, true);
1177 QtFontEncoding *enc = size->encodingID(-1, 0, 0, 0, 0, true);
1178 enc->pitch = (spacing_value >= FC_CHARCELL ? 'c' :
1179 (spacing_value >= FC_MONO ? 'm' : 'p'));
1182 FcFontSetDestroy (fonts);
1184 struct FcDefaultFont {
1186 const char *rawname;
1189 const FcDefaultFont defaults[] = {
1190 { "Serif", "serif", false },
1191 { "Sans Serif", "sans-serif", false },
1192 { "Monospace", "monospace", true },
1195 const FcDefaultFont *f = defaults;
1197 QtFontFamily *family = db->family(QLatin1String(f->qtname), true);
1198 family->fixedPitch = f->fixed;
1199 family->synthetic = true;
1200 QtFontFoundry *foundry = family->foundry(QString(), true);
1202 // aliases only make sense for 'common', not for any of the specials
1203 for (int i = 1; i < LanguageCount; ++i) {
1204 if (requiresOpenType(i))
1205 family->writingSystems[i] = QtFontFamily::UnsupportedFT;
1207 family->writingSystems[i] = QtFontFamily::Supported;
1209 family->writingSystems[QFontDatabase::Other] = QtFontFamily::UnsupportedFT;
1211 QtFontStyle::Key styleKey;
1212 for (int i = 0; i < 4; ++i) {
1213 styleKey.style = (i%2) ? QFont::StyleNormal : QFont::StyleItalic;
1214 styleKey.weight = (i > 1) ? QFont::Bold : QFont::Normal;
1215 QtFontStyle *style = foundry->style(styleKey, true);
1216 style->smoothScalable = true;
1217 QtFontSize *size = style->pixelSize(SMOOTH_SCALABLE, true);
1218 QtFontEncoding *enc = size->encodingID(-1, 0, 0, 0, 0, true);
1219 enc->pitch = (f->fixed ? 'm' : 'p');
1224 #endif // QT_NO_FONTCONFIG
1226 static void initializeDb();
1228 static void load(const QString &family = QString(), int script = -1, bool forceXLFD = false)
1230 if (X11->has_fontconfig && !forceXLFD) {
1235 #ifdef QFONTDATABASE_DEBUG
1240 if (family.isNull() && script == -1) {
1243 if (family.isNull()) {
1244 // load all families in all writing systems that match \a script
1245 for (int ws = 1; ws < QFontDatabase::WritingSystemsCount; ++ws) {
1246 if (scriptForWritingSystem[ws] != script)
1248 for (int i = 0; i < numEncodings; ++i) {
1249 if (writingSystems_for_xlfd_encoding[i][ws])
1254 QtFontFamily *f = privateDb()->family(family);
1255 // could reduce this further with some more magic:
1256 // would need to remember the encodings loaded for the family.
1257 if (!f || !f->xlfdLoaded)
1258 loadXlfds(family.toLatin1(), -1);
1262 #ifdef QFONTDATABASE_DEBUG
1263 FD_DEBUG("QFontDatabase: load(%s, %d) took %d ms",
1264 family.toLatin1().constData(), script, t.elapsed());
1268 static void checkSymbolFont(QtFontFamily *family)
1270 if (!family || family->symbol_checked || family->fontFilename.isEmpty())
1272 // qDebug() << "checking " << family->rawName;
1273 family->symbol_checked = true;
1275 QFontEngine::FaceId id;
1276 id.filename = family->fontFilename;
1277 id.index = family->fontFileIndex;
1278 QFreetypeFace *f = QFreetypeFace::getFace(id);
1280 qWarning("checkSymbolFonts: Couldn't open face %s (%s/%d)",
1281 qPrintable(family->name), family->fontFilename.data(), family->fontFileIndex);
1284 for (int i = 0; i < f->face->num_charmaps; ++i) {
1285 FT_CharMap cm = f->face->charmaps[i];
1286 if (cm->encoding == FT_ENCODING_ADOBE_CUSTOM
1287 || cm->encoding == FT_ENCODING_MS_SYMBOL) {
1288 for (int x = QFontDatabase::Latin; x < QFontDatabase::Other; ++x)
1289 family->writingSystems[x] = QtFontFamily::Unsupported;
1290 family->writingSystems[QFontDatabase::Other] = QtFontFamily::Supported;
1297 static void checkSymbolFonts(const QString &family = QString())
1299 #ifndef QT_NO_FONTCONFIG
1300 QFontDatabasePrivate *d = privateDb();
1302 if (family.isEmpty()) {
1303 for (int i = 0; i < d->count; ++i)
1304 checkSymbolFont(d->families[i]);
1306 checkSymbolFont(d->family(family));
1311 static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt);
1313 static void initializeDb()
1315 QFontDatabasePrivate *db = privateDb();
1316 if (!db || db->count)
1322 #ifndef QT_NO_FONTCONFIG
1323 if (db->reregisterAppFonts) {
1324 db->reregisterAppFonts = false;
1325 for (int i = 0; i < db->applicationFonts.count(); ++i)
1326 if (!db->applicationFonts.at(i).families.isEmpty()) {
1327 registerFont(&db->applicationFonts[i]);
1332 FD_DEBUG("QFontDatabase: loaded FontConfig: %d ms", int(t.elapsed()));
1337 #ifndef QT_NO_FONTCONFIG
1338 for (int i = 0; i < db->count; i++) {
1339 for (int j = 0; j < db->families[i]->count; ++j) { // each foundry
1340 QtFontFoundry *foundry = db->families[i]->foundries[j];
1341 for (int k = 0; k < foundry->count; ++k) {
1342 QtFontStyle *style = foundry->styles[k];
1343 if (style->key.style != QFont::StyleNormal) continue;
1345 QtFontSize *size = style->pixelSize(SMOOTH_SCALABLE);
1346 if (! size) continue; // should not happen
1347 QtFontEncoding *enc = size->encodingID(-1, 0, 0, 0, 0, true);
1348 if (! enc) continue; // should not happen either
1350 QtFontStyle::Key key = style->key;
1352 // does this style have an italic equivalent?
1353 key.style = QFont::StyleItalic;
1354 QtFontStyle *equiv = foundry->style(key);
1355 if (equiv) continue;
1357 // does this style have an oblique equivalent?
1358 key.style = QFont::StyleOblique;
1359 equiv = foundry->style(key);
1360 if (equiv) continue;
1362 // let's fake one...
1363 equiv = foundry->style(key, true);
1364 equiv->smoothScalable = true;
1366 QtFontSize *equiv_size = equiv->pixelSize(SMOOTH_SCALABLE, true);
1367 QtFontEncoding *equiv_enc = equiv_size->encodingID(-1, 0, 0, 0, 0, true);
1369 // keep the same pitch
1370 equiv_enc->pitch = enc->pitch;
1377 #ifdef QFONTDATABASE_DEBUG
1378 #ifndef QT_NO_FONTCONFIG
1379 if (!X11->has_fontconfig)
1381 // load everything at startup in debug mode.
1384 // print the database
1385 for (int f = 0; f < db->count; f++) {
1386 QtFontFamily *family = db->families[f];
1387 FD_DEBUG("'%s' %s fixed=%s", family->name.latin1(), (family->fixedPitch ? "fixed" : ""),
1388 (family->fixedPitch ? "yes" : "no"));
1389 for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
1390 QFontDatabase::WritingSystem ws = QFontDatabase::WritingSystem(i);
1391 FD_DEBUG("\t%s: %s", QFontDatabase::writingSystemName(ws).toLatin1().constData(),
1392 ((family->writingSystems[i] & QtFontFamily::Supported) ? "Supported" :
1393 (family->writingSystems[i] & QtFontFamily::Unsupported) == QtFontFamily::Unsupported ?
1394 "Unsupported" : "Unknown"));
1397 for (int fd = 0; fd < family->count; fd++) {
1398 QtFontFoundry *foundry = family->foundries[fd];
1399 FD_DEBUG("\t\t'%s'", foundry->name.latin1());
1400 for (int s = 0; s < foundry->count; s++) {
1401 QtFontStyle *style = foundry->styles[s];
1402 FD_DEBUG("\t\t\tstyle: style=%d weight=%d (%s)\n"
1403 "\t\t\tstretch=%d (%s)",
1404 style->key.style, style->key.weight,
1405 style->weightName, style->key.stretch,
1406 style->setwidthName ? style->setwidthName : "nil");
1407 if (style->smoothScalable)
1408 FD_DEBUG("\t\t\t\tsmooth scalable");
1409 else if (style->bitmapScalable)
1410 FD_DEBUG("\t\t\t\tbitmap scalable");
1411 if (style->pixelSizes) {
1412 qDebug("\t\t\t\t%d pixel sizes", style->count);
1413 for (int z = 0; z < style->count; ++z) {
1414 QtFontSize *size = style->pixelSizes + z;
1415 for (int e = 0; e < size->count; ++e) {
1416 FD_DEBUG("\t\t\t\t size %5d pitch %c encoding %s",
1418 size->encodings[e].pitch,
1419 xlfd_for_id(size->encodings[e].encoding));
1426 #endif // QFONTDATABASE_DEBUG
1430 // --------------------------------------------------------------------------------------
1432 // --------------------------------------------------------------------------------------
1434 static const char *styleHint(const QFontDef &request)
1436 const char *stylehint = 0;
1437 switch (request.styleHint) {
1438 case QFont::SansSerif:
1439 stylehint = "sans-serif";
1442 stylehint = "serif";
1444 case QFont::TypeWriter:
1445 stylehint = "monospace";
1448 if (request.fixedPitch)
1449 stylehint = "monospace";
1455 #ifndef QT_NO_FONTCONFIG
1457 void qt_addPatternProps(FcPattern *pattern, int screen, int script, const QFontDef &request)
1459 double size_value = qMax(qreal(1.), request.pixelSize);
1460 FcPatternDel(pattern, FC_PIXEL_SIZE);
1461 FcPatternAddDouble(pattern, FC_PIXEL_SIZE, size_value);
1463 if (X11->display && QX11Info::appDepth(screen) <= 8) {
1464 FcPatternDel(pattern, FC_ANTIALIAS);
1465 // can't do antialiasing on 8bpp
1466 FcPatternAddBool(pattern, FC_ANTIALIAS, false);
1467 } else if (request.styleStrategy & (QFont::PreferAntialias|QFont::NoAntialias)) {
1468 FcPatternDel(pattern, FC_ANTIALIAS);
1469 FcPatternAddBool(pattern, FC_ANTIALIAS,
1470 !(request.styleStrategy & QFont::NoAntialias));
1473 if (script != QUnicodeTables::Common && *specialLanguages[script] != '\0') {
1474 Q_ASSERT(script < QUnicodeTables::ScriptCount);
1475 FcLangSet *ls = FcLangSetCreate();
1476 FcLangSetAdd(ls, (const FcChar8*)specialLanguages[script]);
1477 FcPatternDel(pattern, FC_LANG);
1478 FcPatternAddLangSet(pattern, FC_LANG, ls);
1479 FcLangSetDestroy(ls);
1482 if (!request.styleName.isEmpty()) {
1483 QByteArray cs = request.styleName.toUtf8();
1484 FcPatternAddString(pattern, FC_STYLE, (const FcChar8 *) cs.constData());
1488 int weight_value = FC_WEIGHT_BLACK;
1489 if (request.weight == 0)
1490 weight_value = FC_WEIGHT_MEDIUM;
1491 else if (request.weight < (QFont::Light + QFont::Normal) / 2)
1492 weight_value = FC_WEIGHT_LIGHT;
1493 else if (request.weight < (QFont::Normal + QFont::DemiBold) / 2)
1494 weight_value = FC_WEIGHT_MEDIUM;
1495 else if (request.weight < (QFont::DemiBold + QFont::Bold) / 2)
1496 weight_value = FC_WEIGHT_DEMIBOLD;
1497 else if (request.weight < (QFont::Bold + QFont::Black) / 2)
1498 weight_value = FC_WEIGHT_BOLD;
1499 FcPatternDel(pattern, FC_WEIGHT);
1500 FcPatternAddInteger(pattern, FC_WEIGHT, weight_value);
1502 int slant_value = FC_SLANT_ROMAN;
1503 if (request.style == QFont::StyleItalic)
1504 slant_value = FC_SLANT_ITALIC;
1505 else if (request.style == QFont::StyleOblique)
1506 slant_value = FC_SLANT_OBLIQUE;
1507 FcPatternDel(pattern, FC_SLANT);
1508 FcPatternAddInteger(pattern, FC_SLANT, slant_value);
1510 int stretch = request.stretch;
1513 FcPatternDel(pattern, FC_WIDTH);
1514 FcPatternAddInteger(pattern, FC_WIDTH, stretch);
1517 static bool preferScalable(const QFontDef &request)
1519 return request.styleStrategy & (QFont::PreferOutline|QFont::ForceOutline|QFont::PreferQuality|QFont::PreferAntialias);
1523 static FcPattern *getFcPattern(const QFontPrivate *fp, int script, const QFontDef &request)
1525 if (!X11->has_fontconfig)
1528 FcPattern *pattern = FcPatternCreate();
1533 value.type = FcTypeString;
1536 QStringList families_and_foundries = familyList(request);
1537 for (int i = 0; i < families_and_foundries.size(); ++i) {
1538 QString family, foundry;
1539 parseFontName(families_and_foundries.at(i), foundry, family);
1540 if (!family.isEmpty()) {
1541 QByteArray cs = family.toUtf8();
1542 value.u.s = (const FcChar8 *)cs.data();
1543 FcPatternAdd(pattern, FC_FAMILY, value, FcTrue);
1546 QT_PREPEND_NAMESPACE(match)(script, request, family, foundry, -1, &desc);
1547 if (!foundry.isEmpty()) {
1548 QByteArray cs = foundry.toUtf8();
1549 value.u.s = (const FcChar8 *)cs.data();
1550 FcPatternAddWeak(pattern, FC_FOUNDRY, value, FcTrue);
1555 const char *stylehint = styleHint(request);
1557 value.u.s = (const FcChar8 *)stylehint;
1558 FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue);
1561 if (!request.ignorePitch) {
1562 char pitch_value = FC_PROPORTIONAL;
1563 if (request.fixedPitch || (desc.family && desc.family->fixedPitch))
1564 pitch_value = FC_MONO;
1565 FcPatternAddInteger(pattern, FC_SPACING, pitch_value);
1567 FcPatternAddBool(pattern, FC_OUTLINE, !(request.styleStrategy & QFont::PreferBitmap));
1568 if (preferScalable(request) || (desc.style && desc.style->smoothScalable))
1569 FcPatternAddBool(pattern, FC_SCALABLE, true);
1571 qt_addPatternProps(pattern, fp->screen, script, request);
1573 FcConfigSubstitute(0, pattern, FcMatchPattern);
1574 FcDefaultSubstitute(pattern);
1576 // these should only get added to the pattern _after_ substitution
1577 // append the default fallback font for the specified script
1578 extern QString qt_fallback_font_family(int);
1579 QString fallback = qt_fallback_font_family(script);
1580 if (!fallback.isEmpty()) {
1581 QByteArray cs = fallback.toUtf8();
1582 value.u.s = (const FcChar8 *)cs.data();
1583 FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue);
1586 // add the default family
1587 QString defaultFamily = QApplication::font().family();
1588 QByteArray cs = defaultFamily.toUtf8();
1589 value.u.s = (const FcChar8 *)cs.data();
1590 FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue);
1592 // add QFont::defaultFamily() to the list, for compatibility with
1593 // previous versions
1594 defaultFamily = QApplication::font().defaultFamily();
1595 cs = defaultFamily.toUtf8();
1596 value.u.s = (const FcChar8 *)cs.data();
1597 FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue);
1603 static void FcFontSetRemove(FcFontSet *fs, int at)
1605 Q_ASSERT(at < fs->nfont);
1606 FcPatternDestroy(fs->fonts[at]);
1607 int len = (--fs->nfont - at) * sizeof(FcPattern *);;
1609 memmove(fs->fonts + at, fs->fonts + at + 1, len);
1612 static QFontEngine *tryPatternLoad(FcPattern *match, int screen,
1613 const QFontDef &request, int script)
1615 #ifdef FONT_MATCH_DEBUG
1617 FcPatternGetString(match, FC_FAMILY, 0, &fam);
1618 FM_DEBUG("==== trying %s\n", fam);
1620 FM_DEBUG("passes charset test\n");
1622 QFontEngineX11FT *engine = 0;
1623 if (!match) // probably no fonts available.
1626 if (script != QUnicodeTables::Common) {
1627 // skip font if it doesn't support the language we want
1628 if (specialChars[script]) {
1629 // need to check the charset, as the langset doesn't work for these scripts
1631 if (FcPatternGetCharSet(match, FC_CHARSET, 0, &cs) != FcResultMatch)
1633 if (!FcCharSetHasChar(cs, specialChars[script]))
1635 } else if (*specialLanguages[script] != '\0'){
1636 FcLangSet *langSet = 0;
1637 if (FcPatternGetLangSet(match, FC_LANG, 0, &langSet) != FcResultMatch)
1639 if (FcLangSetHasLang(langSet, (const FcChar8*)specialLanguages[script]) != FcLangEqual)
1644 // enforce non-antialiasing if requested. the ft font engine looks at this property.
1645 if (request.styleStrategy & QFont::NoAntialias) {
1646 FcPatternDel(match, FC_ANTIALIAS);
1647 FcPatternAddBool(match, FC_ANTIALIAS, false);
1650 engine = new QFontEngineX11FT(match, qt_FcPatternToQFontDef(match, request), screen);
1651 if (engine->invalid()) {
1652 FM_DEBUG(" --> invalid!\n");
1655 } else if (scriptRequiresOpenType(script)) {
1656 HB_Face hbFace = engine->harfbuzzFace();
1657 if (!hbFace || !hbFace->supported_scripts[script]) {
1658 FM_DEBUG(" OpenType support missing for script\n");
1667 FcFontSet *qt_fontSetForPattern(FcPattern *pattern, const QFontDef &request)
1670 FcFontSet *fs = FcFontSort(0, pattern, FcTrue, 0, &result);
1671 #ifdef FONT_MATCH_DEBUG
1672 FM_DEBUG("first font in fontset:\n");
1673 FcPatternPrint(fs->fonts[0]);
1676 FcBool forceScalable = request.styleStrategy & QFont::ForceOutline;
1678 // remove fonts if they are not scalable (and should be)
1679 if (forceScalable && fs) {
1680 for (int i = 0; i < fs->nfont; ++i) {
1681 FcPattern *font = fs->fonts[i];
1684 res = FcPatternGetBool(font, FC_SCALABLE, 0, &scalable);
1685 if (res != FcResultMatch || !scalable) {
1686 FcFontSetRemove(fs, i);
1687 #ifdef FONT_MATCH_DEBUG
1688 FM_DEBUG("removing pattern:");
1689 FcPatternPrint(font);
1696 FM_DEBUG("final pattern contains %d fonts\n", fs->nfont);
1701 static QFontEngine *loadFc(const QFontPrivate *fp, int script, const QFontDef &request)
1703 FM_DEBUG("===================== loadFc: script=%d family='%s'\n", script, request.family.toLatin1().data());
1704 FcPattern *pattern = getFcPattern(fp, script, request);
1706 #ifdef FONT_MATCH_DEBUG
1707 FM_DEBUG("\n\nfinal FcPattern contains:\n");
1708 FcPatternPrint(pattern);
1711 QFontEngine *fe = 0;
1713 FcPattern *match = FcFontMatch(0, pattern, &res);
1714 fe = tryPatternLoad(match, fp->screen, request, script);
1716 FcFontSet *fs = qt_fontSetForPattern(pattern, request);
1719 FcPatternDestroy(match);
1724 for (int i = 0; !fe && i < fs->nfont; ++i) {
1725 match = FcFontRenderPrepare(NULL, pattern, fs->fonts[i]);
1726 fe = tryPatternLoad(match, fp->screen, request, script);
1729 FcPatternDestroy(match);
1732 FcFontSetDestroy(fs);
1734 FM_DEBUG("engine for script %d is %s\n", script, fe ? fe->fontDef.family.toLatin1().data(): "(null)");
1737 && script == QUnicodeTables::Common
1738 && !(request.styleStrategy & QFont::NoFontMerging) && !fe->symbol) {
1739 fe = new QFontEngineMultiFT(fe, match, pattern, fp->screen, request);
1741 FcPatternDestroy(pattern);
1743 FcPatternDestroy(match);
1748 static FcPattern *queryFont(const FcChar8 *file, const QByteArray &data, int id, FcBlanks *blanks, int *count)
1750 #if FC_VERSION < 20402
1752 return FcFreeTypeQuery(file, id, blanks, count);
1755 return FcFreeTypeQuery(file, id, blanks, count);
1757 extern FT_Library qt_getFreetype();
1758 FT_Library lib = qt_getFreetype();
1760 FcPattern *pattern = 0;
1763 if (!FT_New_Memory_Face(lib, (const FT_Byte *)data.constData(), data.size(), id, &face)) {
1764 *count = face->num_faces;
1766 pattern = FcFreeTypeQueryFace(face, file, id, blanks);
1774 #endif // QT_NO_FONTCONFIG
1776 static QFontEngine *loadRaw(const QFontPrivate *fp, const QFontDef &request)
1778 Q_ASSERT(fp && fp->rawMode);
1780 QByteArray xlfd = request.family.toLatin1();
1781 FM_DEBUG("Loading XLFD (rawmode) '%s'", xlfd.data());
1785 if (!(xfs = XLoadQueryFont(QX11Info::display(), xlfd.data())))
1786 if (!(xfs = XLoadQueryFont(QX11Info::display(), "fixed")))
1789 fe = new QFontEngineXLFD(xfs, xlfd, 0);
1790 if (! qt_fillFontDef(xfs, &fe->fontDef, fp->dpi, 0) &&
1791 ! qt_fillFontDef(xlfd, &fe->fontDef, fp->dpi, 0))
1792 fe->fontDef = QFontDef();
1796 QFontEngine *QFontDatabase::loadXlfd(int screen, int script, const QFontDef &request, int force_encoding_id)
1798 QMutexLocker locker(fontDatabaseMutex());
1801 FM_DEBUG() << "---> loadXlfd: request is" << request.family;
1802 QStringList families_and_foundries = familyList(request);
1803 const char *stylehint = styleHint(request);
1805 families_and_foundries << QString::fromLatin1(stylehint);
1806 families_and_foundries << QString();
1807 FM_DEBUG() << "loadXlfd: list is" << families_and_foundries;
1808 for (int i = 0; i < families_and_foundries.size(); ++i) {
1809 QString family, foundry;
1810 QT_PREPEND_NAMESPACE(parseFontName)(families_and_foundries.at(i), foundry, family);
1811 FM_DEBUG("loadXlfd: >>>>>>>>>>>>>>trying to match '%s' encoding=%d", family.toLatin1().data(), force_encoding_id);
1812 QT_PREPEND_NAMESPACE(match)(script, request, family, foundry, force_encoding_id, &desc, QList<int>(), true);
1817 QFontEngine *fe = 0;
1818 if (force_encoding_id != -1
1819 || (request.styleStrategy & QFont::NoFontMerging)
1820 || (desc.family && desc.family->writingSystems[QFontDatabase::Symbol] & QtFontFamily::Supported)) {
1822 int px = desc.size->pixelSize;
1823 if (desc.style->smoothScalable && px == SMOOTH_SCALABLE)
1824 px = request.pixelSize;
1825 else if (desc.style->bitmapScalable && px == 0)
1826 px = request.pixelSize;
1828 QByteArray xlfd("-");
1829 xlfd += desc.foundry->name.isEmpty() ? QByteArray("*") : desc.foundry->name.toLatin1();
1831 xlfd += desc.family->name.isEmpty() ? QByteArray("*") : desc.family->name.toLatin1();
1833 xlfd += desc.style->weightName ? desc.style->weightName : "*";
1835 xlfd += (desc.style->key.style == QFont::StyleItalic
1837 : (desc.style->key.style == QFont::StyleOblique ? 'o' : 'r'));
1839 xlfd += desc.style->setwidthName ? desc.style->setwidthName : "*";
1840 // ### handle add-style
1842 xlfd += QByteArray::number(px);
1844 xlfd += QByteArray::number(desc.encoding->xpoint);
1846 xlfd += QByteArray::number(desc.encoding->xres);
1848 xlfd += QByteArray::number(desc.encoding->yres);
1850 xlfd += desc.encoding->pitch;
1852 xlfd += QByteArray::number(desc.encoding->avgwidth);
1854 xlfd += xlfd_for_id(desc.encoding->encoding);
1856 FM_DEBUG(" using XLFD: %s\n", xlfd.data());
1858 const int mib = xlfd_encoding[desc.encoding->encoding].mib;
1860 if ((xfs = XLoadQueryFont(QX11Info::display(), xlfd))) {
1861 fe = new QFontEngineXLFD(xfs, xlfd, mib);
1862 const int dpi = QX11Info::appDpiY();
1863 if (!qt_fillFontDef(xfs, &fe->fontDef, dpi, &desc)
1864 && !qt_fillFontDef(xlfd, &fe->fontDef, dpi, &desc)) {
1865 initFontDef(desc, request, &fe->fontDef);
1870 fe = new QFontEngineBox(request.pixelSize);
1871 fe->fontDef = QFontDef();
1874 QList<int> encodings;
1875 if (desc.encoding) {
1876 if (desc.encoding->encoding >= 0)
1877 encodings.append(int(desc.encoding->encoding));
1881 // append all other encodings for the matched font
1882 for (int i = 0; i < desc.size->count; ++i) {
1883 QtFontEncoding *e = desc.size->encodings + i;
1884 if (e == desc.encoding || e->encoding < 0)
1886 encodings.append(int(e->encoding));
1889 // fill in the missing encodings
1890 const XlfdEncoding *enc = xlfd_encoding;
1891 for (; enc->name; ++enc) {
1892 if (!encodings.contains(enc->id) && enc->id >= 0) {
1893 encodings.append(enc->id);
1897 #if defined(FONT_MATCH_DEBUG)
1898 FM_DEBUG(" using MultiXLFD, encodings:");
1899 for (int i = 0; i < encodings.size(); ++i) {
1900 const int id = encodings.at(i);
1901 FM_DEBUG(" %2d: %s", xlfd_encoding[id].id, xlfd_encoding[id].name);
1905 fe = new QFontEngineMultiXLFD(request, encodings, screen);
1910 #if (defined(QT_ARCH_ARM) || defined(QT_ARCH_ARMV6)) && defined(Q_CC_GNU) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
1911 #define NEEDS_GCC_BUG_WORKAROUND
1914 #ifdef NEEDS_GCC_BUG_WORKAROUND
1915 static inline void gccBugWorkaround(const QFontDef &req)
1918 snprintf(buffer, 8, "%f", req.pixelSize);
1923 Loads a QFontEngine for the specified \a script that matches the
1924 QFontDef \e request member variable.
1926 void QFontDatabase::load(const QFontPrivate *d, int script)
1928 Q_ASSERT(script >= 0 && script < QUnicodeTables::ScriptCount);
1930 // normalize the request to get better caching
1931 QFontDef req = d->request;
1932 if (req.pixelSize <= 0)
1933 req.pixelSize = qFloor(qt_pixelSize(req.pointSize, d->dpi) * 100.0 + 0.5) * 0.01;
1934 if (req.pixelSize < 1)
1937 #ifdef NEEDS_GCC_BUG_WORKAROUND
1938 // req.pixelSize ends up with a bogus value unless this workaround is called
1939 gccBugWorkaround(req);
1942 if (req.weight == 0)
1943 req.weight = QFont::Normal;
1944 if (req.stretch == 0)
1947 QFontCache::Key key(req, d->rawMode ? QUnicodeTables::Common : script, d->screen);
1949 getEngineData(d, key);
1951 // the cached engineData could have already loaded the engine we want
1952 if (d->engineData->engines[script])
1955 // set it to the actual pointsize, so QFontInfo will do the right thing
1956 if (req.pointSize < 0)
1957 req.pointSize = qt_pointSize(req.pixelSize, d->dpi);
1960 QFontEngine *fe = QFontCache::instance()->findEngine(key);
1963 QMutexLocker locker(fontDatabaseMutex());
1964 if (!privateDb()->count)
1967 const bool mainThread = (qApp->thread() == QThread::currentThread());
1968 if (qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) {
1969 fe = new QTestFontEngine(req.pixelSize);
1971 } else if (d->rawMode) {
1973 fe = loadRaw(d, req);
1974 #ifndef QT_NO_FONTCONFIG
1975 } else if (X11->has_fontconfig) {
1976 fe = loadFc(d, script, req);
1978 } else if (mainThread && qt_is_gui_used) {
1979 fe = loadXlfd(d->screen, script, req);
1982 fe = new QFontEngineBox(req.pixelSize);
1983 fe->fontDef = QFontDef();
1986 if (fe->symbol || (d->request.styleStrategy & QFont::NoFontMerging)) {
1987 for (int i = 0; i < QUnicodeTables::ScriptCount; ++i) {
1988 if (!d->engineData->engines[i]) {
1989 d->engineData->engines[i] = fe;
1994 d->engineData->engines[script] = fe;
1997 QFontCache::instance()->insertEngine(key, fe);
2000 // Needed for fontconfig version < 2.2.97
2001 #ifndef FC_FAMILYLANG
2002 #define FC_FAMILYLANG "familylang"
2005 static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
2007 #if defined(QT_NO_FONTCONFIG)
2010 if (!X11->has_fontconfig)
2013 FcConfig *config = FcConfigGetCurrent();
2017 FcFontSet *set = FcConfigGetFonts(config, FcSetApplication);
2019 FcConfigAppFontAddFile(config, (const FcChar8 *)":/non-existent");
2020 set = FcConfigGetFonts(config, FcSetApplication); // try again
2025 QString fileNameForQuery = fnt->fileName;
2026 #if FC_VERSION < 20402
2029 if (!fnt->data.isEmpty()) {
2032 tmp.write(fnt->data);
2034 fileNameForQuery = tmp.fileName();
2039 FcBlanks *blanks = FcConfigGetBlanks(0);
2042 QStringList families;
2043 QFontDatabasePrivate *db = privateDb();
2045 FcPattern *pattern = 0;
2047 pattern = queryFont((const FcChar8 *)QFile::encodeName(fileNameForQuery).constData(),
2048 fnt->data, id, blanks, &count);
2052 FcPatternDel(pattern, FC_FILE);
2053 QByteArray cs = fnt->fileName.toUtf8();
2054 FcPatternAddString(pattern, FC_FILE, (const FcChar8 *) cs.constData());
2056 FcChar8 *fam = 0, *familylang = 0;
2058 for (i = 0; ; i++) {
2059 if (FcPatternGetString(pattern, FC_FAMILYLANG, i, &familylang) != FcResultMatch)
2061 QString familyLang = QString::fromUtf8((const char *) familylang);
2062 if (familyLang.compare(db->systemLang, Qt::CaseInsensitive) == 0) {
2068 if (FcPatternGetString(pattern, FC_FAMILY, n, &fam) == FcResultMatch) {
2069 QString family = QString::fromUtf8(reinterpret_cast<const char *>(fam));
2073 if (!FcFontSetAdd(set, pattern))
2077 } while (pattern && id < count);
2079 fnt->families = families;
2083 bool QFontDatabase::removeApplicationFont(int handle)
2085 #if defined(QT_NO_FONTCONFIG)
2088 QMutexLocker locker(fontDatabaseMutex());
2090 QFontDatabasePrivate *db = privateDb();
2091 if (handle < 0 || handle >= db->applicationFonts.count())
2094 FcConfigAppFontClear(0);
2096 db->applicationFonts[handle] = QFontDatabasePrivate::ApplicationFont();
2098 db->reregisterAppFonts = true;
2104 bool QFontDatabase::removeAllApplicationFonts()
2106 #if defined(QT_NO_FONTCONFIG)
2109 QMutexLocker locker(fontDatabaseMutex());
2111 QFontDatabasePrivate *db = privateDb();
2112 if (db->applicationFonts.isEmpty())
2115 FcConfigAppFontClear(0);
2116 db->applicationFonts.clear();
2122 bool QFontDatabase::supportsThreadedFontRendering()
2124 #if defined(QT_NO_FONTCONFIG)
2127 return X11->has_fontconfig;
2131 QString QFontDatabase::resolveFontFamilyAlias(const QString &family)
2133 #if defined(QT_NO_FONTCONFIG)
2136 FcPattern *pattern = FcPatternCreate();
2140 QByteArray cs = family.toUtf8();
2141 FcPatternAddString(pattern, FC_FAMILY, (const FcChar8 *) cs.constData());
2142 FcConfigSubstitute(0, pattern, FcMatchPattern);
2143 FcDefaultSubstitute(pattern);
2145 FcChar8 *familyAfterSubstitution;
2146 FcPatternGetString(pattern, FC_FAMILY, 0, &familyAfterSubstitution);
2147 QString resolved = QString::fromUtf8((const char *) familyAfterSubstitution);
2148 FcPatternDestroy(pattern);