source: trunk/src/gui/text/qfontdatabase_win.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 39.2 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 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** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qt_windows.h"
43#include <qmath.h>
44#include <private/qapplication_p.h>
45#include "qfont_p.h"
46#include "qfontengine_p.h"
47#include "qpaintdevice.h"
48#include <private/qsystemlibrary_p.h>
49#include "qabstractfileengine.h"
50#include "qendian.h"
51
52#ifdef Q_OS_WINCE
53# include <QTemporaryFile>
54#endif
55
56QT_BEGIN_NAMESPACE
57
58extern HDC shared_dc(); // common dc for all fonts
59
60#ifdef MAKE_TAG
61#undef MAKE_TAG
62#endif
63// GetFontData expects the tags in little endian ;(
64#define MAKE_TAG(ch1, ch2, ch3, ch4) (\
65 (((quint32)(ch4)) << 24) | \
66 (((quint32)(ch3)) << 16) | \
67 (((quint32)(ch2)) << 8) | \
68 ((quint32)(ch1)) \
69 )
70
71static HFONT stock_sysfont = 0;
72
73static bool localizedName(const QString &name)
74{
75 const QChar *c = name.unicode();
76 for(int i = 0; i < name.length(); ++i) {
77 if(c[i].unicode() >= 0x100)
78 return true;
79 }
80 return false;
81}
82
83static inline quint16 getUShort(const unsigned char *p)
84{
85 quint16 val;
86 val = *p++ << 8;
87 val |= *p;
88
89 return val;
90}
91
92static QString getEnglishName(const uchar *table, quint32 bytes)
93{
94 QString i18n_name;
95 enum {
96 NameRecordSize = 12,
97 FamilyId = 1,
98 MS_LangIdEnglish = 0x009
99 };
100
101 // get the name table
102 quint16 count;
103 quint16 string_offset;
104 const unsigned char *names;
105
106 int microsoft_id = -1;
107 int apple_id = -1;
108 int unicode_id = -1;
109
110 if(getUShort(table) != 0)
111 goto error;
112
113 count = getUShort(table+2);
114 string_offset = getUShort(table+4);
115 names = table + 6;
116
117 if(string_offset >= bytes || 6 + count*NameRecordSize > string_offset)
118 goto error;
119
120 for(int i = 0; i < count; ++i) {
121 // search for the correct name entry
122
123 quint16 platform_id = getUShort(names + i*NameRecordSize);
124 quint16 encoding_id = getUShort(names + 2 + i*NameRecordSize);
125 quint16 language_id = getUShort(names + 4 + i*NameRecordSize);
126 quint16 name_id = getUShort(names + 6 + i*NameRecordSize);
127
128 if(name_id != FamilyId)
129 continue;
130
131 enum {
132 PlatformId_Unicode = 0,
133 PlatformId_Apple = 1,
134 PlatformId_Microsoft = 3
135 };
136
137 quint16 length = getUShort(names + 8 + i*NameRecordSize);
138 quint16 offset = getUShort(names + 10 + i*NameRecordSize);
139 if(DWORD(string_offset + offset + length) >= bytes)
140 continue;
141
142 if ((platform_id == PlatformId_Microsoft
143 && (encoding_id == 0 || encoding_id == 1))
144 && (language_id & 0x3ff) == MS_LangIdEnglish
145 && microsoft_id == -1)
146 microsoft_id = i;
147 // not sure if encoding id 4 for Unicode is utf16 or ucs4...
148 else if(platform_id == PlatformId_Unicode && encoding_id < 4 && unicode_id == -1)
149 unicode_id = i;
150 else if(platform_id == PlatformId_Apple && encoding_id == 0 && language_id == 0)
151 apple_id = i;
152 }
153 {
154 bool unicode = false;
155 int id = -1;
156 if(microsoft_id != -1) {
157 id = microsoft_id;
158 unicode = true;
159 } else if(apple_id != -1) {
160 id = apple_id;
161 unicode = false;
162 } else if (unicode_id != -1) {
163 id = unicode_id;
164 unicode = true;
165 }
166 if(id != -1) {
167 quint16 length = getUShort(names + 8 + id*NameRecordSize);
168 quint16 offset = getUShort(names + 10 + id*NameRecordSize);
169 if(unicode) {
170 // utf16
171
172 length /= 2;
173 i18n_name.resize(length);
174 QChar *uc = (QChar *) i18n_name.unicode();
175 const unsigned char *string = table + string_offset + offset;
176 for(int i = 0; i < length; ++i)
177 uc[i] = getUShort(string + 2*i);
178 } else {
179 // Apple Roman
180
181 i18n_name.resize(length);
182 QChar *uc = (QChar *) i18n_name.unicode();
183 const unsigned char *string = table + string_offset + offset;
184 for(int i = 0; i < length; ++i)
185 uc[i] = QLatin1Char(string[i]);
186 }
187 }
188 }
189 error:
190 //qDebug("got i18n name of '%s' for font '%s'", i18n_name.latin1(), familyName.toLocal8Bit().data());
191 return i18n_name;
192}
193
194static QString getEnglishName(const QString &familyName)
195{
196 QString i18n_name;
197
198 HDC hdc = GetDC( 0 );
199 LOGFONT lf;
200 memset(&lf, 0, sizeof(LOGFONT));
201 memcpy(lf.lfFaceName, familyName.utf16(), qMin(LF_FACESIZE, familyName.length()) * sizeof(wchar_t));
202 lf.lfCharSet = DEFAULT_CHARSET;
203 HFONT hfont = CreateFontIndirect(&lf);
204
205 if(!hfont) {
206 ReleaseDC(0, hdc);
207 return QString();
208 }
209
210 HGDIOBJ oldobj = SelectObject( hdc, hfont );
211
212 const DWORD name_tag = MAKE_TAG( 'n', 'a', 'm', 'e' );
213
214 // get the name table
215 unsigned char *table = 0;
216
217 DWORD bytes = GetFontData( hdc, name_tag, 0, 0, 0 );
218 if ( bytes == GDI_ERROR ) {
219 // ### Unused variable
220 /* int err = GetLastError(); */
221 goto error;
222 }
223
224 table = new unsigned char[bytes];
225 GetFontData(hdc, name_tag, 0, table, bytes);
226 if ( bytes == GDI_ERROR )
227 goto error;
228
229 i18n_name = getEnglishName(table, bytes);
230error:
231 delete [] table;
232 SelectObject( hdc, oldobj );
233 DeleteObject( hfont );
234 ReleaseDC( 0, hdc );
235
236 //qDebug("got i18n name of '%s' for font '%s'", i18n_name.latin1(), familyName.toLocal8Bit().data());
237 return i18n_name;
238}
239
240static
241void addFontToDatabase(QString familyName, const QString &scriptName,
242 TEXTMETRIC *textmetric,
243 const FONTSIGNATURE *signature,
244 int type)
245{
246 const int script = -1;
247 const QString foundryName;
248 Q_UNUSED(script);
249
250 bool italic = false;
251 int weight;
252 bool fixed;
253 bool ttf;
254 bool scalable;
255 int size;
256
257// QString escript = QString::fromWCharArray(f->elfScript);
258// qDebug("script=%s", escript.latin1());
259
260 NEWTEXTMETRIC *tm = (NEWTEXTMETRIC *)textmetric;
261 fixed = !(tm->tmPitchAndFamily & TMPF_FIXED_PITCH);
262 ttf = (tm->tmPitchAndFamily & TMPF_TRUETYPE);
263 scalable = tm->tmPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE);
264 size = scalable ? SMOOTH_SCALABLE : tm->tmHeight;
265 italic = tm->tmItalic;
266 weight = tm->tmWeight;
267
268 // the "@family" fonts are just the same as "family". Ignore them.
269 if (familyName[0] != QLatin1Char('@') && !familyName.startsWith(QLatin1String("WST_"))) {
270 QtFontStyle::Key styleKey;
271 styleKey.style = italic ? QFont::StyleItalic : QFont::StyleNormal;
272 if (weight < 400)
273 styleKey.weight = QFont::Light;
274 else if (weight < 600)
275 styleKey.weight = QFont::Normal;
276 else if (weight < 700)
277 styleKey.weight = QFont::DemiBold;
278 else if (weight < 800)
279 styleKey.weight = QFont::Bold;
280 else
281 styleKey.weight = QFont::Black;
282
283 QtFontFamily *family = privateDb()->family(familyName, true);
284
285 if(ttf && localizedName(familyName) && family->english_name.isEmpty())
286 family->english_name = getEnglishName(familyName);
287
288 QtFontFoundry *foundry = family->foundry(foundryName, true);
289 QtFontStyle *style = foundry->style(styleKey, true);
290 style->smoothScalable = scalable;
291 style->pixelSize( size, TRUE);
292
293 // add fonts windows can generate for us:
294 if (styleKey.weight <= QFont::DemiBold) {
295 QtFontStyle::Key key(styleKey);
296 key.weight = QFont::Bold;
297 QtFontStyle *style = foundry->style(key, true);
298 style->smoothScalable = scalable;
299 style->pixelSize( size, TRUE);
300 }
301 if (styleKey.style != QFont::StyleItalic) {
302 QtFontStyle::Key key(styleKey);
303 key.style = QFont::StyleItalic;
304 QtFontStyle *style = foundry->style(key, true);
305 style->smoothScalable = scalable;
306 style->pixelSize( size, TRUE);
307 }
308 if (styleKey.weight <= QFont::DemiBold && styleKey.style != QFont::StyleItalic) {
309 QtFontStyle::Key key(styleKey);
310 key.weight = QFont::Bold;
311 key.style = QFont::StyleItalic;
312 QtFontStyle *style = foundry->style(key, true);
313 style->smoothScalable = scalable;
314 style->pixelSize( size, TRUE);
315 }
316
317 family->fixedPitch = fixed;
318
319 if (!family->writingSystemCheck && type & TRUETYPE_FONTTYPE) {
320 quint32 unicodeRange[4] = {
321 signature->fsUsb[0], signature->fsUsb[1],
322 signature->fsUsb[2], signature->fsUsb[3]
323 };
324#ifdef Q_WS_WINCE
325 if (signature->fsUsb[0] == 0) {
326 // If the unicode ranges bit mask is zero then
327 // EnumFontFamiliesEx failed to determine it properly.
328 // In this case we just pretend that the font supports all languages.
329 unicodeRange[0] = 0xbfffffff; // second most significant bit must be zero
330 unicodeRange[1] = 0xffffffff;
331 unicodeRange[2] = 0xffffffff;
332 unicodeRange[3] = 0xffffffff;
333 }
334#endif
335 quint32 codePageRange[2] = {
336 signature->fsCsb[0], signature->fsCsb[1]
337 };
338 QList<QFontDatabase::WritingSystem> systems = determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange);
339
340 for (int i = 0; i < systems.count(); ++i) {
341 QFontDatabase::WritingSystem writingSystem = systems.at(i);
342
343 // ### Hack to work around problem with Thai text on Windows 7. Segoe UI contains
344 // the symbol for Baht, and Windows thus reports that it supports the Thai script.
345 // Since it's the default UI font on this platform, most widgets will be unable to
346 // display Thai text by default. As a temporary work around, we special case Segoe UI
347 // and remove the Thai script from its list of supported writing systems.
348 if (writingSystem != QFontDatabase::Thai || familyName != QLatin1String("Segoe UI"))
349 family->writingSystems[writingSystem] = QtFontFamily::Supported;
350 }
351 } else if (!family->writingSystemCheck) {
352 //qDebug("family='%s' script=%s", family->name.latin1(), script.latin1());
353 if (scriptName == QLatin1String("Western")
354 || scriptName == QLatin1String("Baltic")
355 || scriptName == QLatin1String("Central European")
356 || scriptName == QLatin1String("Turkish")
357 || scriptName == QLatin1String("Vietnamese"))
358 family->writingSystems[QFontDatabase::Latin] = QtFontFamily::Supported;
359 else if (scriptName == QLatin1String("Thai"))
360 family->writingSystems[QFontDatabase::Thai] = QtFontFamily::Supported;
361 else if (scriptName == QLatin1String("Symbol")
362 || scriptName == QLatin1String("Other"))
363 family->writingSystems[QFontDatabase::Symbol] = QtFontFamily::Supported;
364 else if (scriptName == QLatin1String("OEM/Dos"))
365 family->writingSystems[QFontDatabase::Latin] = QtFontFamily::Supported;
366 else if (scriptName == QLatin1String("CHINESE_GB2312"))
367 family->writingSystems[QFontDatabase::SimplifiedChinese] = QtFontFamily::Supported;
368 else if (scriptName == QLatin1String("CHINESE_BIG5"))
369 family->writingSystems[QFontDatabase::TraditionalChinese] = QtFontFamily::Supported;
370 else if (scriptName == QLatin1String("Cyrillic"))
371 family->writingSystems[QFontDatabase::Cyrillic] = QtFontFamily::Supported;
372 else if (scriptName == QLatin1String("Hangul"))
373 family->writingSystems[QFontDatabase::Korean] = QtFontFamily::Supported;
374 else if (scriptName == QLatin1String("Hebrew"))
375 family->writingSystems[QFontDatabase::Hebrew] = QtFontFamily::Supported;
376 else if (scriptName == QLatin1String("Greek"))
377 family->writingSystems[QFontDatabase::Greek] = QtFontFamily::Supported;
378 else if (scriptName == QLatin1String("Japanese"))
379 family->writingSystems[QFontDatabase::Japanese] = QtFontFamily::Supported;
380 else if (scriptName == QLatin1String("Arabic"))
381 family->writingSystems[QFontDatabase::Arabic] = QtFontFamily::Supported;
382 }
383 }
384}
385
386static
387int CALLBACK
388storeFont(ENUMLOGFONTEX* f, NEWTEXTMETRICEX *textmetric, int type, LPARAM /*p*/)
389{
390 QString familyName = QString::fromWCharArray(f->elfLogFont.lfFaceName);
391 QString script = QString::fromWCharArray(f->elfScript);
392
393 FONTSIGNATURE signature = textmetric->ntmFontSig;
394
395 // NEWTEXTMETRICEX is a NEWTEXTMETRIC, which according to the documentation is
396 // identical to a TEXTMETRIC except for the last four members, which we don't use
397 // anyway
398 addFontToDatabase(familyName, script, (TEXTMETRIC *)textmetric, &signature, type);
399 // keep on enumerating
400 return 1;
401}
402
403static
404void populate_database(const QString& fam)
405{
406 QFontDatabasePrivate *d = privateDb();
407 if (!d)
408 return;
409
410 QtFontFamily *family = 0;
411 if(!fam.isEmpty()) {
412 family = d->family(fam);
413 if(family && family->loaded)
414 return;
415 } else if (d->count) {
416 return;
417 }
418
419 HDC dummy = GetDC(0);
420
421 LOGFONT lf;
422 lf.lfCharSet = DEFAULT_CHARSET;
423 if (fam.isNull()) {
424 lf.lfFaceName[0] = 0;
425 } else {
426 memcpy(lf.lfFaceName, fam.utf16(), sizeof(wchar_t) * qMin(fam.length() + 1, 32)); // 32 = Windows hard-coded
427 }
428 lf.lfPitchAndFamily = 0;
429
430 EnumFontFamiliesEx(dummy, &lf,
431 (FONTENUMPROC)storeFont, (LPARAM)privateDb(), 0);
432
433 ReleaseDC(0, dummy);
434
435 for (int i = 0; i < d->applicationFonts.count(); ++i) {
436 QFontDatabasePrivate::ApplicationFont fnt = d->applicationFonts.at(i);
437 if (!fnt.memoryFont)
438 continue;
439 for (int j = 0; j < fnt.families.count(); ++j) {
440 const QString familyName = fnt.families.at(j);
441 HDC hdc = GetDC(0);
442 LOGFONT lf;
443 memset(&lf, 0, sizeof(LOGFONT));
444 memcpy(lf.lfFaceName, familyName.utf16(), sizeof(wchar_t) * qMin(LF_FACESIZE, familyName.size()));
445 lf.lfCharSet = DEFAULT_CHARSET;
446 HFONT hfont = CreateFontIndirect(&lf);
447 HGDIOBJ oldobj = SelectObject(hdc, hfont);
448
449 TEXTMETRIC textMetrics;
450 GetTextMetrics(hdc, &textMetrics);
451
452 addFontToDatabase(familyName, QString(),
453 &textMetrics,
454 &fnt.signatures.at(j),
455 TRUETYPE_FONTTYPE);
456
457 SelectObject(hdc, oldobj);
458 DeleteObject(hfont);
459 ReleaseDC(0, hdc);
460 }
461 }
462
463 if(!fam.isEmpty()) {
464 family = d->family(fam);
465 if(family) {
466 if(!family->writingSystemCheck) {
467 }
468 family->loaded = true;
469 }
470 }
471}
472
473static void initializeDb()
474{
475 QFontDatabasePrivate *db = privateDb();
476 if (!db || db->count)
477 return;
478
479 populate_database(QString());
480
481#ifdef QFONTDATABASE_DEBUG
482 // print the database
483 for (int f = 0; f < db->count; f++) {
484 QtFontFamily *family = db->families[f];
485 qDebug(" %s: %p", qPrintable(family->name), family);
486 populate_database(family->name);
487
488#if 0
489 qDebug(" scripts supported:");
490 for (int i = 0; i < QUnicodeTables::ScriptCount; i++)
491 if(family->writingSystems[i] & QtFontFamily::Supported)
492 qDebug(" %d", i);
493 for (int fd = 0; fd < family->count; fd++) {
494 QtFontFoundry *foundry = family->foundries[fd];
495 qDebug(" %s", foundry->name.latin1());
496 for (int s = 0; s < foundry->count; s++) {
497 QtFontStyle *style = foundry->styles[s];
498 qDebug(" style: style=%d weight=%d smooth=%d", style->key.style,
499 style->key.weight, style->smoothScalable );
500 if(!style->smoothScalable) {
501 for(int i = 0; i < style->count; ++i) {
502 qDebug(" %d", style->pixelSizes[i].pixelSize);
503 }
504 }
505 }
506 }
507#endif
508 }
509#endif // QFONTDATABASE_DEBUG
510
511}
512
513static inline void load(const QString &family = QString(), int = -1)
514{
515 populate_database(family);
516}
517
518
519
520
521
522// --------------------------------------------------------------------------------------
523// font loader
524// --------------------------------------------------------------------------------------
525
526
527
528static void initFontInfo(QFontEngineWin *fe, const QFontDef &request, const QFontPrivate *fp)
529{
530 fe->fontDef = request; // most settings are equal
531
532 HDC dc = ((request.styleStrategy & QFont::PreferDevice) && fp->hdc) ? fp->hdc : shared_dc();
533 SelectObject(dc, fe->hfont);
534 wchar_t n[64];
535 GetTextFace(dc, 64, n);
536 fe->fontDef.family = QString::fromWCharArray(n);
537 fe->fontDef.fixedPitch = !(fe->tm.tmPitchAndFamily & TMPF_FIXED_PITCH);
538 if (fe->fontDef.pointSize < 0) {
539 fe->fontDef.pointSize = fe->fontDef.pixelSize * 72. / fp->dpi;
540 } else if (fe->fontDef.pixelSize == -1) {
541 fe->fontDef.pixelSize = qRound(fe->fontDef.pointSize * fp->dpi / 72.);
542 }
543}
544
545
546static const char *other_tryFonts[] = {
547 "Arial",
548 "MS UI Gothic",
549 "Gulim",
550 "SimSun",
551 "PMingLiU",
552 "Arial Unicode MS",
553 0
554};
555
556static const char *jp_tryFonts [] = {
557 "MS UI Gothic",
558 "Arial",
559 "Gulim",
560 "SimSun",
561 "PMingLiU",
562 "Arial Unicode MS",
563 0
564};
565
566static const char *ch_CN_tryFonts [] = {
567 "SimSun",
568 "Arial",
569 "PMingLiU",
570 "Gulim",
571 "MS UI Gothic",
572 "Arial Unicode MS",
573 0
574};
575
576static const char *ch_TW_tryFonts [] = {
577 "PMingLiU",
578 "Arial",
579 "SimSun",
580 "Gulim",
581 "MS UI Gothic",
582 "Arial Unicode MS",
583 0
584};
585
586static const char *kr_tryFonts[] = {
587 "Gulim",
588 "Arial",
589 "PMingLiU",
590 "SimSun",
591 "MS UI Gothic",
592 "Arial Unicode MS",
593 0
594};
595
596static const char **tryFonts = 0;
597
598
599static inline HFONT systemFont()
600{
601 if (stock_sysfont == 0)
602 stock_sysfont = (HFONT)GetStockObject(SYSTEM_FONT);
603 return stock_sysfont;
604}
605
606#if !defined(DEFAULT_GUI_FONT)
607#define DEFAULT_GUI_FONT 17
608#endif
609
610static
611QFontEngine *loadEngine(int script, const QFontPrivate *fp, const QFontDef &request, const QtFontDesc *desc,
612 const QStringList &family_list)
613{
614 LOGFONT lf;
615 memset(&lf, 0, sizeof(LOGFONT));
616
617 bool useDevice = (request.styleStrategy & QFont::PreferDevice) && fp->hdc;
618
619 HDC hdc = shared_dc();
620 QString font_name = desc->family->name;
621
622 if (useDevice) {
623 hdc = fp->hdc;
624 font_name = request.family;
625 }
626
627 bool stockFont = false;
628 bool preferClearTypeAA = false;
629
630 HFONT hfont = 0;
631
632 if (fp->rawMode) { // will choose a stock font
633 int f, deffnt = SYSTEM_FONT;
634 QString fam = desc->family->name.toLower();
635 if (fam == QLatin1String("default"))
636 f = deffnt;
637 else if (fam == QLatin1String("system"))
638 f = SYSTEM_FONT;
639#ifndef Q_WS_WINCE
640 else if (fam == QLatin1String("system_fixed"))
641 f = SYSTEM_FIXED_FONT;
642 else if (fam == QLatin1String("ansi_fixed"))
643 f = ANSI_FIXED_FONT;
644 else if (fam == QLatin1String("ansi_var"))
645 f = ANSI_VAR_FONT;
646 else if (fam == QLatin1String("device_default"))
647 f = DEVICE_DEFAULT_FONT;
648 else if (fam == QLatin1String("oem_fixed"))
649 f = OEM_FIXED_FONT;
650#endif
651 else if (fam[0] == QLatin1Char('#'))
652 f = fam.right(fam.length()-1).toInt();
653 else
654 f = deffnt;
655 hfont = (HFONT)GetStockObject(f);
656 if (!hfont) {
657 qErrnoWarning("QFontEngine::loadEngine: GetStockObject failed");
658 hfont = systemFont();
659 }
660 stockFont = true;
661 } else {
662
663 int hint = FF_DONTCARE;
664 switch (request.styleHint) {
665 case QFont::Helvetica:
666 hint = FF_SWISS;
667 break;
668 case QFont::Times:
669 hint = FF_ROMAN;
670 break;
671 case QFont::Courier:
672 hint = FF_MODERN;
673 break;
674 case QFont::OldEnglish:
675 hint = FF_DECORATIVE;
676 break;
677 case QFont::System:
678 hint = FF_MODERN;
679 break;
680 default:
681 break;
682 }
683
684 lf.lfHeight = -qRound(request.pixelSize);
685 lf.lfWidth = 0;
686 lf.lfEscapement = 0;
687 lf.lfOrientation = 0;
688 if (desc->style->key.weight == 50)
689 lf.lfWeight = FW_DONTCARE;
690 else
691 lf.lfWeight = (desc->style->key.weight*900)/99;
692 lf.lfItalic = (desc->style->key.style != QFont::StyleNormal);
693 lf.lfCharSet = DEFAULT_CHARSET;
694
695 int strat = OUT_DEFAULT_PRECIS;
696 if (request.styleStrategy & QFont::PreferBitmap) {
697 strat = OUT_RASTER_PRECIS;
698#ifndef Q_WS_WINCE
699 } else if (request.styleStrategy & QFont::PreferDevice) {
700 strat = OUT_DEVICE_PRECIS;
701 } else if (request.styleStrategy & QFont::PreferOutline) {
702 strat = OUT_OUTLINE_PRECIS;
703 } else if (request.styleStrategy & QFont::ForceOutline) {
704 strat = OUT_TT_ONLY_PRECIS;
705#endif
706 }
707
708 lf.lfOutPrecision = strat;
709
710 int qual = DEFAULT_QUALITY;
711
712 if (request.styleStrategy & QFont::PreferMatch)
713 qual = DRAFT_QUALITY;
714#ifndef Q_WS_WINCE
715 else if (request.styleStrategy & QFont::PreferQuality)
716 qual = PROOF_QUALITY;
717#endif
718
719 if (request.styleStrategy & QFont::PreferAntialias) {
720 if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP) {
721 qual = CLEARTYPE_QUALITY;
722 preferClearTypeAA = true;
723 } else {
724 qual = ANTIALIASED_QUALITY;
725 }
726 } else if (request.styleStrategy & QFont::NoAntialias) {
727 qual = NONANTIALIASED_QUALITY;
728 }
729
730 lf.lfQuality = qual;
731
732 lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
733 lf.lfPitchAndFamily = DEFAULT_PITCH | hint;
734
735 QString fam = font_name;
736
737 if(fam.isEmpty())
738 fam = QLatin1String("MS Sans Serif");
739
740 if ((fam == QLatin1String("MS Sans Serif"))
741 && (request.style == QFont::StyleItalic || (-lf.lfHeight > 18 && -lf.lfHeight != 24))) {
742 fam = QLatin1String("Arial"); // MS Sans Serif has bearing problems in italic, and does not scale
743 }
744 if (fam == QLatin1String("Courier") && !(request.styleStrategy & QFont::PreferBitmap))
745 fam = QLatin1String("Courier New");
746
747 memcpy(lf.lfFaceName, fam.utf16(), sizeof(wchar_t) * qMin(fam.length() + 1, 32)); // 32 = Windows hard-coded
748 hfont = CreateFontIndirect(&lf);
749 if (!hfont)
750 qErrnoWarning("QFontEngine::loadEngine: CreateFontIndirect failed");
751
752 stockFont = (hfont == 0);
753 bool ttf = false;
754 int avWidth = 0;
755 BOOL res;
756 HGDIOBJ oldObj = SelectObject(hdc, hfont);
757
758 TEXTMETRIC tm;
759 res = GetTextMetrics(hdc, &tm);
760 avWidth = tm.tmAveCharWidth;
761 ttf = tm.tmPitchAndFamily & TMPF_TRUETYPE;
762
763 SelectObject(hdc, oldObj);
764
765 if (hfont && (!ttf || request.stretch != 100)) {
766 DeleteObject(hfont);
767 if (!res)
768 qErrnoWarning("QFontEngine::loadEngine: GetTextMetrics failed");
769 lf.lfWidth = avWidth * request.stretch/100;
770 hfont = CreateFontIndirect(&lf);
771 if (!hfont)
772 qErrnoWarning("QFontEngine::loadEngine: CreateFontIndirect with stretch failed");
773 }
774
775#ifndef Q_WS_WINCE
776 if (hfont == 0) {
777 hfont = (HFONT)GetStockObject(ANSI_VAR_FONT);
778 stockFont = true;
779 }
780#else
781 if (hfont == 0) {
782 hfont = (HFONT)GetStockObject(SYSTEM_FONT);
783 stockFont = true;
784 }
785#endif
786
787 }
788 QFontEngineWin *few = new QFontEngineWin(font_name, hfont, stockFont, lf);
789
790 if (preferClearTypeAA)
791 few->glyphFormat = QFontEngineGlyphCache::Raster_RGBMask;
792
793 // Also check for OpenType tables when using complex scripts
794 // ### TODO: This only works for scripts that require OpenType. More generally
795 // for scripts that do not require OpenType we should just look at the list of
796 // supported writing systems in the font's OS/2 table.
797 if (scriptRequiresOpenType(script)) {
798 HB_Face hbFace = few->harfbuzzFace();
799 if (!hbFace || !hbFace->supported_scripts[script]) {
800 FM_DEBUG(" OpenType support missing for script\n");
801 delete few;
802 return 0;
803 }
804 }
805
806 QFontEngine *fe = few;
807 initFontInfo(few, request, fp);
808 if(script == QUnicodeTables::Common
809 && !(request.styleStrategy & QFont::NoFontMerging)
810 && !(desc->family->writingSystems[QFontDatabase::Symbol] & QtFontFamily::Supported)) {
811 if(!tryFonts) {
812 LANGID lid = GetUserDefaultLangID();
813 switch( lid&0xff ) {
814 case LANG_CHINESE: // Chinese (Taiwan)
815 if ( lid == 0x0804 ) // Taiwan
816 tryFonts = ch_TW_tryFonts;
817 else
818 tryFonts = ch_CN_tryFonts;
819 break;
820 case LANG_JAPANESE:
821 tryFonts = jp_tryFonts;
822 break;
823 case LANG_KOREAN:
824 tryFonts = kr_tryFonts;
825 break;
826 default:
827 tryFonts = other_tryFonts;
828 break;
829 }
830 }
831 QStringList fm = QFontDatabase().families();
832 QStringList list = family_list;
833 const char **tf = tryFonts;
834 while(tf && *tf) {
835 if(fm.contains(QLatin1String(*tf)))
836 list << QLatin1String(*tf);
837 ++tf;
838 }
839 QFontEngine *mfe = new QFontEngineMultiWin(few, list);
840 mfe->fontDef = fe->fontDef;
841 fe = mfe;
842 }
843 return fe;
844}
845
846const char *styleHint(const QFontDef &request)
847{
848 const char *stylehint = 0;
849 switch (request.styleHint) {
850 case QFont::SansSerif:
851 stylehint = "Arial";
852 break;
853 case QFont::Serif:
854 stylehint = "Times New Roman";
855 break;
856 case QFont::TypeWriter:
857 stylehint = "Courier New";
858 break;
859 default:
860 if (request.fixedPitch)
861 stylehint = "Courier New";
862 break;
863 }
864 return stylehint;
865}
866
867static QFontEngine *loadWin(const QFontPrivate *d, int script, const QFontDef &req)
868{
869 // list of families to try
870 QStringList family_list = familyList(req);
871
872 const char *stylehint = styleHint(d->request);
873 if (stylehint)
874 family_list << QLatin1String(stylehint);
875
876 // append the default fallback font for the specified script
877 // family_list << ... ; ###########
878
879 // add the default family
880 QString defaultFamily = QApplication::font().family();
881 if (! family_list.contains(defaultFamily))
882 family_list << defaultFamily;
883
884 // add QFont::defaultFamily() to the list, for compatibility with
885 // previous versions
886 family_list << QApplication::font().defaultFamily();
887
888 // null family means find the first font matching the specified script
889 family_list << QString();
890
891 QtFontDesc desc;
892 QFontEngine *fe = 0;
893 QList<int> blacklistedFamilies;
894
895 while (!fe) {
896 for (int i = 0; i < family_list.size(); ++i) {
897 QString family, foundry;
898 parseFontName(family_list.at(i), foundry, family);
899 FM_DEBUG("loadWin: >>>>>>>>>>>>>>trying to match '%s'", family.toLatin1().data());
900 QT_PREPEND_NAMESPACE(match)(script, req, family, foundry, -1, &desc, blacklistedFamilies);
901 if (desc.family)
902 break;
903 }
904 if (!desc.family)
905 break;
906 fe = loadEngine(script, d, req, &desc, family_list);
907 if (!fe)
908 blacklistedFamilies.append(desc.familyIndex);
909 }
910 return fe;
911}
912
913void QFontDatabase::load(const QFontPrivate *d, int script)
914{
915 // sanity checks
916 if (!qApp)
917 qWarning("QFontDatabase::load: Must construct QApplication first");
918 Q_ASSERT(script >= 0 && script < QUnicodeTables::ScriptCount);
919
920 // normalize the request to get better caching
921 QFontDef req = d->request;
922 if (req.pixelSize <= 0)
923 req.pixelSize = qreal((req.pointSize * d->dpi) / 72.);
924 if (req.pixelSize < 1)
925 req.pixelSize = 1;
926 if (req.weight == 0)
927 req.weight = QFont::Normal;
928 if (req.stretch == 0)
929 req.stretch = 100;
930
931 QFontCache::Key key(req, d->rawMode ? QUnicodeTables::Common : script, d->screen);
932 if (!d->engineData)
933 getEngineData(d, key);
934
935 // the cached engineData could have already loaded the engine we want
936 if (d->engineData->engines[script])
937 return;
938
939 QFontEngine *fe = QFontCache::instance()->findEngine(key);
940
941 // set it to the actual pointsize, so QFontInfo will do the right thing
942 if (req.pointSize < 0)
943 req.pointSize = req.pixelSize*72./d->dpi;
944
945 if (!fe) {
946 if (qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) {
947 fe = new QTestFontEngine(req.pixelSize);
948 fe->fontDef = req;
949 } else {
950 QMutexLocker locker(fontDatabaseMutex());
951 if (!privateDb()->count)
952 initializeDb();
953 fe = loadWin(d, script, req);
954 }
955 if (!fe) {
956 fe = new QFontEngineBox(req.pixelSize);
957 fe->fontDef = QFontDef();
958 }
959 }
960 d->engineData->engines[script] = fe;
961 fe->ref.ref();
962 QFontCache::instance()->insertEngine(key, fe);
963}
964
965#if !defined(FR_PRIVATE)
966#define FR_PRIVATE 0x10
967#endif
968
969typedef int (WINAPI *PtrAddFontResourceExW)(LPCWSTR, DWORD, PVOID);
970typedef HANDLE (WINAPI *PtrAddFontMemResourceEx)(PVOID, DWORD, PVOID, DWORD *);
971typedef BOOL (WINAPI *PtrRemoveFontResourceExW)(LPCWSTR, DWORD, PVOID);
972typedef BOOL (WINAPI *PtrRemoveFontMemResourceEx)(HANDLE);
973
974static QList<quint32> getTrueTypeFontOffsets(const uchar *fontData)
975{
976 QList<quint32> offsets;
977 const quint32 headerTag = *reinterpret_cast<const quint32 *>(fontData);
978 if (headerTag != MAKE_TAG('t', 't', 'c', 'f')) {
979 if (headerTag != MAKE_TAG(0, 1, 0, 0)
980 && headerTag != MAKE_TAG('O', 'T', 'T', 'O')
981 && headerTag != MAKE_TAG('t', 'r', 'u', 'e')
982 && headerTag != MAKE_TAG('t', 'y', 'p', '1'))
983 return offsets;
984 offsets << 0;
985 return offsets;
986 }
987 const quint32 numFonts = qFromBigEndian<quint32>(fontData + 8);
988 for (uint i = 0; i < numFonts; ++i) {
989 offsets << qFromBigEndian<quint32>(fontData + 12 + i * 4);
990 }
991 return offsets;
992}
993
994static void getFontTable(const uchar *fileBegin, const uchar *data, quint32 tag, const uchar **table, quint32 *length)
995{
996 const quint16 numTables = qFromBigEndian<quint16>(data + 4);
997 for (uint i = 0; i < numTables; ++i) {
998 const quint32 offset = 12 + 16 * i;
999 if (*reinterpret_cast<const quint32 *>(data + offset) == tag) {
1000 *table = fileBegin + qFromBigEndian<quint32>(data + offset + 8);
1001 *length = qFromBigEndian<quint32>(data + offset + 12);
1002 return;
1003 }
1004 }
1005 *table = 0;
1006 *length = 0;
1007 return;
1008}
1009
1010static void getFamiliesAndSignatures(const QByteArray &fontData, QFontDatabasePrivate::ApplicationFont *appFont)
1011{
1012 const uchar *data = reinterpret_cast<const uchar *>(fontData.constData());
1013
1014 QList<quint32> offsets = getTrueTypeFontOffsets(data);
1015 if (offsets.isEmpty())
1016 return;
1017
1018 for (int i = 0; i < offsets.count(); ++i) {
1019 const uchar *font = data + offsets.at(i);
1020 const uchar *table;
1021 quint32 length;
1022 getFontTable(data, font, MAKE_TAG('n', 'a', 'm', 'e'), &table, &length);
1023 if (!table)
1024 continue;
1025 QString name = getEnglishName(table, length);
1026 if (name.isEmpty())
1027 continue;
1028
1029 appFont->families << name;
1030 FONTSIGNATURE signature;
1031 getFontTable(data, font, MAKE_TAG('O', 'S', '/', '2'), &table, &length);
1032 if (table && length >= 86) {
1033 // See also qfontdatabase_mac.cpp, offsets taken from OS/2 table in the TrueType spec
1034 signature.fsUsb[0] = qFromBigEndian<quint32>(table + 42);
1035 signature.fsUsb[1] = qFromBigEndian<quint32>(table + 46);
1036 signature.fsUsb[2] = qFromBigEndian<quint32>(table + 50);
1037 signature.fsUsb[3] = qFromBigEndian<quint32>(table + 54);
1038
1039 signature.fsCsb[0] = qFromBigEndian<quint32>(table + 78);
1040 signature.fsCsb[1] = qFromBigEndian<quint32>(table + 82);
1041 } else {
1042 memset(&signature, 0, sizeof(signature));
1043 }
1044 appFont->signatures << signature;
1045 }
1046}
1047
1048static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
1049{
1050 if(!fnt->data.isEmpty()) {
1051#ifndef Q_OS_WINCE
1052 PtrAddFontMemResourceEx ptrAddFontMemResourceEx = (PtrAddFontMemResourceEx)QSystemLibrary::resolve(QLatin1String("gdi32"),
1053 "AddFontMemResourceEx");
1054 if (!ptrAddFontMemResourceEx)
1055 return;
1056#endif
1057 getFamiliesAndSignatures(fnt->data, fnt);
1058 if (fnt->families.isEmpty())
1059 return;
1060
1061#ifdef Q_OS_WINCE
1062 HANDLE handle = 0;
1063
1064 {
1065#ifdef QT_NO_TEMPORARYFILE
1066 wchar_t lpBuffer[MAX_PATH];
1067 GetTempPath(MAX_PATH, lpBuffer);
1068 QString s = QString::fromWCharArray(lpBuffer);
1069 QFile tempfile(s + QLatin1String("/font") + QString::number(GetTickCount()) + QLatin1String(".ttf"));
1070 if (!tempfile.open(QIODevice::ReadWrite))
1071#else
1072 QTemporaryFile tempfile(QLatin1String("XXXXXXXX.ttf"));
1073 if (!tempfile.open())
1074#endif // QT_NO_TEMPORARYFILE
1075 return;
1076 if (tempfile.write(fnt->data) == -1)
1077 return;
1078
1079#ifndef QT_NO_TEMPORARYFILE
1080 tempfile.setAutoRemove(false);
1081#endif
1082 fnt->fileName = QFileInfo(tempfile.fileName()).absoluteFilePath();
1083 }
1084
1085 if (AddFontResource((LPCWSTR)fnt->fileName.utf16()) == 0) {
1086 QFile(fnt->fileName).remove();
1087 return;
1088 }
1089#else
1090 DWORD dummy = 0;
1091 HANDLE handle = ptrAddFontMemResourceEx((void *)fnt->data.constData(), fnt->data.size(), 0,
1092 &dummy);
1093 if (handle == 0)
1094 return;
1095#endif // Q_OS_WINCE
1096
1097 fnt->handle = handle;
1098 fnt->data = QByteArray();
1099 fnt->memoryFont = true;
1100 } else {
1101 QFile f(fnt->fileName);
1102 if (!f.open(QIODevice::ReadOnly))
1103 return;
1104 QByteArray data = f.readAll();
1105 f.close();
1106 getFamiliesAndSignatures(data, fnt);
1107
1108#ifdef Q_OS_WINCE
1109 QFileInfo fileinfo(fnt->fileName);
1110 fnt->fileName = fileinfo.absoluteFilePath();
1111 if (AddFontResource((LPCWSTR)fnt->fileName.utf16()) == 0)
1112 return;
1113#else
1114 PtrAddFontResourceExW ptrAddFontResourceExW = (PtrAddFontResourceExW)QSystemLibrary::resolve(QLatin1String("gdi32"),
1115 "AddFontResourceExW");
1116 if (!ptrAddFontResourceExW
1117 || ptrAddFontResourceExW((wchar_t*)fnt->fileName.utf16(), FR_PRIVATE, 0) == 0)
1118 return;
1119#endif // Q_OS_WINCE
1120
1121 fnt->memoryFont = false;
1122 }
1123}
1124
1125bool QFontDatabase::removeApplicationFont(int handle)
1126{
1127 QMutexLocker locker(fontDatabaseMutex());
1128
1129 QFontDatabasePrivate *db = privateDb();
1130 if (handle < 0 || handle >= db->applicationFonts.count())
1131 return false;
1132
1133 const QFontDatabasePrivate::ApplicationFont font = db->applicationFonts.at(handle);
1134 db->applicationFonts[handle] = QFontDatabasePrivate::ApplicationFont();
1135 if (font.memoryFont) {
1136#ifdef Q_OS_WINCE
1137 bool removeSucceeded = RemoveFontResource((LPCWSTR)font.fileName.utf16());
1138 QFile tempfile(font.fileName);
1139 tempfile.remove();
1140 if (!removeSucceeded)
1141 return false;
1142#else
1143 PtrRemoveFontMemResourceEx ptrRemoveFontMemResourceEx = (PtrRemoveFontMemResourceEx)QSystemLibrary::resolve(QLatin1String("gdi32"),
1144 "RemoveFontMemResourceEx");
1145 if (!ptrRemoveFontMemResourceEx
1146 || !ptrRemoveFontMemResourceEx(font.handle))
1147 return false;
1148#endif // Q_OS_WINCE
1149 } else {
1150#ifdef Q_OS_WINCE
1151 if (!RemoveFontResource((LPCWSTR)font.fileName.utf16()))
1152 return false;
1153#else
1154 PtrRemoveFontResourceExW ptrRemoveFontResourceExW = (PtrRemoveFontResourceExW)QSystemLibrary::resolve(QLatin1String("gdi32"),
1155 "RemoveFontResourceExW");
1156 if (!ptrRemoveFontResourceExW
1157 || !ptrRemoveFontResourceExW((LPCWSTR)font.fileName.utf16(), FR_PRIVATE, 0))
1158 return false;
1159#endif // Q_OS_WINCE
1160 }
1161
1162 db->invalidate();
1163 return true;
1164}
1165
1166bool QFontDatabase::removeAllApplicationFonts()
1167{
1168 QMutexLocker locker(fontDatabaseMutex());
1169
1170 QFontDatabasePrivate *db = privateDb();
1171 for (int i = 0; i < db->applicationFonts.count(); ++i)
1172 if (!removeApplicationFont(i))
1173 return false;
1174 return true;
1175}
1176
1177bool QFontDatabase::supportsThreadedFontRendering()
1178{
1179 return true;
1180}
1181
1182QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.