|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2009 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 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 <private/qapplication_p.h> |
|
43 /* :QTP:JKOO-7XPHCJ:resolve header split problem */ |
|
44 #include "qglobal.h" |
|
45 #include "qdir.h" |
|
46 #include "qfont_p.h" |
|
47 #include "qfontengine_s60_p.h" |
|
48 #include "qabstractfileengine.h" |
|
49 #include "qdesktopservices.h" |
|
50 #include "qpixmap_s60_p.h" |
|
51 #include "qt_s60_p.h" |
|
52 #include "qendian.h" |
|
53 #include <private/qcore_symbian_p.h> |
|
54 #if defined(QT_NO_FREETYPE) |
|
55 #include <OPENFONT.H> |
|
56 #include <graphics/openfontrasterizer.h> |
|
57 #endif |
|
58 |
|
59 QT_BEGIN_NAMESPACE |
|
60 |
|
61 QFileInfoList alternativeFilePaths(const QString &path, const QStringList &nameFilters, |
|
62 QDir::Filters filters = QDir::NoFilter, QDir::SortFlags sort = QDir::NoSort, |
|
63 bool uniqueFileNames = true) |
|
64 { |
|
65 QFileInfoList result; |
|
66 |
|
67 // Prepare a 'soft to hard' drive list: W:, X: ... A:, Z: |
|
68 QStringList driveStrings; |
|
69 foreach (const QFileInfo &drive, QDir::drives()) |
|
70 driveStrings.append(drive.absolutePath()); |
|
71 driveStrings.sort(); |
|
72 const QString zDriveString(QLatin1String("Z:/")); |
|
73 driveStrings.removeAll(zDriveString); |
|
74 driveStrings.prepend(zDriveString); |
|
75 |
|
76 QStringList uniqueFileNameList; |
|
77 for (int i = driveStrings.count() - 1; i >= 0; --i) { |
|
78 const QDir dirOnDrive(driveStrings.at(i) + path); |
|
79 const QFileInfoList entriesOnDrive = dirOnDrive.entryInfoList(nameFilters, filters, sort); |
|
80 if (uniqueFileNames) { |
|
81 foreach(const QFileInfo &entry, entriesOnDrive) { |
|
82 if (!uniqueFileNameList.contains(entry.fileName())) { |
|
83 uniqueFileNameList.append(entry.fileName()); |
|
84 result.append(entry); |
|
85 } |
|
86 } |
|
87 } else { |
|
88 result.append(entriesOnDrive); |
|
89 } |
|
90 } |
|
91 return result; |
|
92 } |
|
93 |
|
94 #if defined(QT_NO_FREETYPE) |
|
95 class QFontDatabaseS60StoreImplementation : public QFontDatabaseS60Store |
|
96 { |
|
97 public: |
|
98 QFontDatabaseS60StoreImplementation(); |
|
99 ~QFontDatabaseS60StoreImplementation(); |
|
100 |
|
101 const QFontEngineS60Extensions *extension(const QString &typeface) const; |
|
102 |
|
103 private: |
|
104 RHeap* m_heap; |
|
105 CFontStore *m_store; |
|
106 COpenFontRasterizer *m_rasterizer; |
|
107 mutable QHash<QString, const QFontEngineS60Extensions *> m_extensions; |
|
108 }; |
|
109 |
|
110 QFontDatabaseS60StoreImplementation::QFontDatabaseS60StoreImplementation() |
|
111 { |
|
112 m_heap = User::ChunkHeap(NULL, 0x1000, 0x100000); |
|
113 QT_TRAP_THROWING( |
|
114 m_store = CFontStore::NewL(m_heap); |
|
115 m_rasterizer = COpenFontRasterizer::NewL(TUid::Uid(0x101F7F5E)); |
|
116 CleanupStack::PushL(m_rasterizer); |
|
117 m_store->InstallRasterizerL(m_rasterizer); |
|
118 CleanupStack::Pop(m_rasterizer);); |
|
119 |
|
120 QStringList filters; |
|
121 filters.append(QString::fromLatin1("*.ttf")); |
|
122 filters.append(QString::fromLatin1("*.ccc")); |
|
123 const QFileInfoList fontFiles = alternativeFilePaths(QString::fromLatin1("resource\\Fonts"), filters); |
|
124 foreach (const QFileInfo &fontFileInfo, fontFiles) { |
|
125 const QString fontFile = QDir::toNativeSeparators(fontFileInfo.absoluteFilePath()); |
|
126 TPtrC fontFilePtr(qt_QString2TPtrC(fontFile)); |
|
127 QT_TRAP_THROWING(m_store->AddFileL(fontFilePtr)); |
|
128 } |
|
129 } |
|
130 QFontDatabaseS60StoreImplementation::~QFontDatabaseS60StoreImplementation() |
|
131 { |
|
132 typedef QHash<QString, const QFontEngineS60Extensions *>::iterator iterator; |
|
133 for (iterator p = m_extensions.begin(); p != m_extensions.end(); ++p) { |
|
134 m_store->ReleaseFont((*p)->fontOwner()); |
|
135 delete *p; |
|
136 } |
|
137 |
|
138 delete m_store; |
|
139 m_heap->Close(); |
|
140 } |
|
141 |
|
142 const QFontEngineS60Extensions *QFontDatabaseS60StoreImplementation::extension(const QString &typeface) const |
|
143 { |
|
144 if (!m_extensions.contains(typeface)) { |
|
145 CFont* font = NULL; |
|
146 TFontSpec spec(qt_QString2TPtrC(typeface), 1); |
|
147 spec.iHeight = 1; |
|
148 const TInt err = m_store->GetNearestFontToDesignHeightInPixels(font, spec); |
|
149 Q_ASSERT(err == KErrNone && font); |
|
150 CBitmapFont *bitmapFont = static_cast<CBitmapFont*>(font); |
|
151 m_extensions.insert(typeface, new QFontEngineS60Extensions(font, bitmapFont->OpenFont())); |
|
152 } |
|
153 return m_extensions.value(typeface); |
|
154 } |
|
155 #else |
|
156 class QFontEngineFTS60 : public QFontEngineFT |
|
157 { |
|
158 public: |
|
159 QFontEngineFTS60(const QFontDef &fd); |
|
160 }; |
|
161 |
|
162 QFontEngineFTS60::QFontEngineFTS60(const QFontDef &fd) |
|
163 : QFontEngineFT(fd) |
|
164 { |
|
165 default_hint_style = HintFull; |
|
166 } |
|
167 #endif // defined(QT_NO_FREETYPE) |
|
168 |
|
169 /* |
|
170 QFontEngineS60::pixelsToPoints, QFontEngineS60::pointsToPixels, QFontEngineMultiS60::QFontEngineMultiS60 |
|
171 and QFontEngineMultiS60::QFontEngineMultiS60 should be in qfontengine_s60.cpp. But since also the |
|
172 Freetype based font rendering need them, they are here. |
|
173 */ |
|
174 qreal QFontEngineS60::pixelsToPoints(qreal pixels, Qt::Orientation orientation) |
|
175 { |
|
176 return (orientation == Qt::Horizontal? |
|
177 S60->screenDevice()->HorizontalPixelsToTwips(pixels) |
|
178 :S60->screenDevice()->VerticalPixelsToTwips(pixels)) / KTwipsPerPoint; |
|
179 } |
|
180 |
|
181 qreal QFontEngineS60::pointsToPixels(qreal points, Qt::Orientation orientation) |
|
182 { |
|
183 const int twips = points * KTwipsPerPoint; |
|
184 return orientation == Qt::Horizontal? |
|
185 S60->screenDevice()->HorizontalTwipsToPixels(twips) |
|
186 :S60->screenDevice()->VerticalTwipsToPixels(twips); |
|
187 } |
|
188 |
|
189 QFontEngineMultiS60::QFontEngineMultiS60(QFontEngine *first, int script, const QStringList &fallbackFamilies) |
|
190 : QFontEngineMulti(fallbackFamilies.size() + 1) |
|
191 , m_script(script) |
|
192 , m_fallbackFamilies(fallbackFamilies) |
|
193 { |
|
194 engines[0] = first; |
|
195 first->ref.ref(); |
|
196 fontDef = engines[0]->fontDef; |
|
197 } |
|
198 |
|
199 void QFontEngineMultiS60::loadEngine(int at) |
|
200 { |
|
201 Q_ASSERT(at < engines.size()); |
|
202 Q_ASSERT(engines.at(at) == 0); |
|
203 |
|
204 QFontDef request = fontDef; |
|
205 request.styleStrategy |= QFont::NoFontMerging; |
|
206 request.family = m_fallbackFamilies.at(at-1); |
|
207 engines[at] = QFontDatabase::findFont(m_script, |
|
208 /*fontprivate*/0, |
|
209 request); |
|
210 Q_ASSERT(engines[at]); |
|
211 } |
|
212 |
|
213 static void initializeDb() |
|
214 { |
|
215 QFontDatabasePrivate *db = privateDb(); |
|
216 if(!db || db->count) |
|
217 return; |
|
218 |
|
219 #if defined(QT_NO_FREETYPE) |
|
220 if (!db->s60Store) |
|
221 db->s60Store = new QFontDatabaseS60StoreImplementation; |
|
222 |
|
223 QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock); |
|
224 |
|
225 const int numTypeFaces = QS60Data::screenDevice()->NumTypefaces(); |
|
226 const QFontDatabaseS60StoreImplementation *store = dynamic_cast<const QFontDatabaseS60StoreImplementation*>(db->s60Store); |
|
227 Q_ASSERT(store); |
|
228 bool fontAdded = false; |
|
229 for (int i = 0; i < numTypeFaces; i++) { |
|
230 TTypefaceSupport typefaceSupport; |
|
231 QS60Data::screenDevice()->TypefaceSupport(typefaceSupport, i); |
|
232 CFont *font; // We have to get a font instance in order to know all the details |
|
233 TFontSpec fontSpec(typefaceSupport.iTypeface.iName, 11); |
|
234 if (QS60Data::screenDevice()->GetNearestFontInPixels(font, fontSpec) != KErrNone) |
|
235 continue; |
|
236 if (font->TypeUid() == KCFbsFontUid) { |
|
237 TOpenFontFaceAttrib faceAttrib; |
|
238 const CFbsFont *cfbsFont = dynamic_cast<const CFbsFont *>(font); |
|
239 Q_ASSERT(cfbsFont); |
|
240 cfbsFont->GetFaceAttrib(faceAttrib); |
|
241 |
|
242 QtFontStyle::Key styleKey; |
|
243 styleKey.style = faceAttrib.IsItalic()?QFont::StyleItalic:QFont::StyleNormal; |
|
244 styleKey.weight = faceAttrib.IsBold()?QFont::Bold:QFont::Normal; |
|
245 |
|
246 QString familyName((const QChar *)typefaceSupport.iTypeface.iName.Ptr(), typefaceSupport.iTypeface.iName.Length()); |
|
247 QtFontFamily *family = db->family(familyName, true); |
|
248 family->fixedPitch = faceAttrib.IsMonoWidth(); |
|
249 QtFontFoundry *foundry = family->foundry(QString(), true); |
|
250 QtFontStyle *style = foundry->style(styleKey, true); |
|
251 style->smoothScalable = typefaceSupport.iIsScalable; |
|
252 style->pixelSize(0, true); |
|
253 |
|
254 const QFontEngineS60Extensions *extension = store->extension(familyName); |
|
255 const QByteArray os2Table = extension->getSfntTable(MAKE_TAG('O', 'S', '/', '2')); |
|
256 const unsigned char* data = reinterpret_cast<const unsigned char*>(os2Table.constData()); |
|
257 const unsigned char* ulUnicodeRange = data + 42; |
|
258 quint32 unicodeRange[4] = { |
|
259 qFromBigEndian<quint32>(ulUnicodeRange), |
|
260 qFromBigEndian<quint32>(ulUnicodeRange + 4), |
|
261 qFromBigEndian<quint32>(ulUnicodeRange + 8), |
|
262 qFromBigEndian<quint32>(ulUnicodeRange + 12) |
|
263 }; |
|
264 const unsigned char* ulCodePageRange = data + 78; |
|
265 quint32 codePageRange[2] = { |
|
266 qFromBigEndian<quint32>(ulCodePageRange), |
|
267 qFromBigEndian<quint32>(ulCodePageRange + 4) |
|
268 }; |
|
269 const QList<QFontDatabase::WritingSystem> writingSystems = |
|
270 determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange); |
|
271 foreach (const QFontDatabase::WritingSystem system, writingSystems) |
|
272 family->writingSystems[system] = QtFontFamily::Supported; |
|
273 |
|
274 fontAdded = true; |
|
275 } |
|
276 QS60Data::screenDevice()->ReleaseFont(font); |
|
277 } |
|
278 |
|
279 Q_ASSERT(fontAdded); |
|
280 |
|
281 lock.relock(); |
|
282 |
|
283 #else // defined(QT_NO_FREETYPE) |
|
284 QDir dir(QDesktopServices::storageLocation(QDesktopServices::FontsLocation)); |
|
285 dir.setNameFilters(QStringList() << QLatin1String("*.ttf") |
|
286 << QLatin1String("*.ttc") << QLatin1String("*.pfa") |
|
287 << QLatin1String("*.pfb")); |
|
288 for (int i = 0; i < int(dir.count()); ++i) { |
|
289 const QByteArray file = QFile::encodeName(dir.absoluteFilePath(dir[i])); |
|
290 db->addTTFile(file); |
|
291 } |
|
292 #endif // defined(QT_NO_FREETYPE) |
|
293 } |
|
294 |
|
295 static inline void load(const QString &family = QString(), int script = -1) |
|
296 { |
|
297 Q_UNUSED(family) |
|
298 Q_UNUSED(script) |
|
299 initializeDb(); |
|
300 } |
|
301 |
|
302 static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt) |
|
303 { |
|
304 Q_UNUSED(fnt); |
|
305 } |
|
306 |
|
307 bool QFontDatabase::removeApplicationFont(int handle) |
|
308 { |
|
309 Q_UNUSED(handle); |
|
310 return false; |
|
311 } |
|
312 |
|
313 bool QFontDatabase::supportsThreadedFontRendering() |
|
314 { |
|
315 return false; |
|
316 } |
|
317 |
|
318 static |
|
319 QFontDef cleanedFontDef(const QFontDef &req) |
|
320 { |
|
321 QFontDef result = req; |
|
322 if (result.pixelSize <= 0) { |
|
323 result.pixelSize = QFontEngineS60::pointsToPixels(qMax(qreal(1.0), result.pointSize)); |
|
324 result.pointSize = 0; |
|
325 } |
|
326 return result; |
|
327 } |
|
328 |
|
329 QFontEngine *QFontDatabase::findFont(int script, const QFontPrivate *, const QFontDef &req) |
|
330 { |
|
331 const QFontCache::Key key(cleanedFontDef(req), script); |
|
332 |
|
333 if (!privateDb()->count) |
|
334 initializeDb(); |
|
335 |
|
336 QFontEngine *fe = QFontCache::instance()->findEngine(key); |
|
337 if (!fe) { |
|
338 // Making sure that fe->fontDef.family will be an existing font. |
|
339 initializeDb(); |
|
340 QFontDatabasePrivate *db = privateDb(); |
|
341 QtFontDesc desc; |
|
342 QList<int> blacklistedFamilies; |
|
343 match(script, req, req.family, QString(), -1, &desc, blacklistedFamilies); |
|
344 if (!desc.family) // falling back to application font |
|
345 desc.family = db->family(QApplication::font().defaultFamily()); |
|
346 Q_ASSERT(desc.family); |
|
347 |
|
348 // Making sure that desc.family supports the requested script |
|
349 QtFontDesc mappedDesc; |
|
350 bool supportsScript = false; |
|
351 do { |
|
352 match(script, req, QString(), QString(), -1, &mappedDesc, blacklistedFamilies); |
|
353 if (mappedDesc.family == desc.family) { |
|
354 supportsScript = true; |
|
355 break; |
|
356 } |
|
357 blacklistedFamilies.append(mappedDesc.familyIndex); |
|
358 } while (mappedDesc.family); |
|
359 if (!supportsScript) { |
|
360 blacklistedFamilies.clear(); |
|
361 match(script, req, QString(), QString(), -1, &mappedDesc, blacklistedFamilies); |
|
362 if (mappedDesc.family) |
|
363 desc = mappedDesc; |
|
364 } |
|
365 |
|
366 const QString fontFamily = desc.family->name; |
|
367 QFontDef request = req; |
|
368 request.family = fontFamily; |
|
369 #if defined(QT_NO_FREETYPE) |
|
370 const QFontDatabaseS60StoreImplementation *store = dynamic_cast<const QFontDatabaseS60StoreImplementation*>(db->s60Store); |
|
371 Q_ASSERT(store); |
|
372 const QFontEngineS60Extensions *extension = store->extension(fontFamily); |
|
373 fe = new QFontEngineS60(request, extension); |
|
374 #else |
|
375 QFontEngine::FaceId faceId; |
|
376 const QtFontFamily * const reqQtFontFamily = db->family(fontFamily); |
|
377 faceId.filename = reqQtFontFamily->fontFilename; |
|
378 faceId.index = reqQtFontFamily->fontFileIndex; |
|
379 |
|
380 QFontEngineFTS60 *fte = new QFontEngineFTS60(cleanedFontDef(request)); |
|
381 if (fte->init(faceId, true, QFontEngineFT::Format_A8)) |
|
382 fe = fte; |
|
383 else |
|
384 delete fte; |
|
385 #endif |
|
386 |
|
387 Q_ASSERT(fe); |
|
388 if (script == QUnicodeTables::Common |
|
389 && !(req.styleStrategy & QFont::NoFontMerging) |
|
390 && !fe->symbol) { |
|
391 |
|
392 QStringList commonFonts; |
|
393 for (int ws = 1; ws < QFontDatabase::WritingSystemsCount; ++ws) { |
|
394 if (scriptForWritingSystem[ws] != script) |
|
395 continue; |
|
396 for (int i = 0; i < db->count; ++i) { |
|
397 if (db->families[i]->writingSystems[ws] & QtFontFamily::Supported) |
|
398 commonFonts.append(db->families[i]->name); |
|
399 } |
|
400 } |
|
401 |
|
402 // Hack: Prioritize .ccc fonts |
|
403 const QString niceEastAsianFont(QLatin1String("Sans MT 936_S60")); |
|
404 if (commonFonts.removeAll(niceEastAsianFont) > 0) |
|
405 commonFonts.prepend(niceEastAsianFont); |
|
406 |
|
407 fe = new QFontEngineMultiS60(fe, script, commonFonts); |
|
408 } |
|
409 } |
|
410 fe->ref.ref(); |
|
411 QFontCache::instance()->insertEngine(key, fe); |
|
412 return fe; |
|
413 } |
|
414 |
|
415 void QFontDatabase::load(const QFontPrivate *d, int script) |
|
416 { |
|
417 QFontEngine *fe = 0; |
|
418 QFontDef req = d->request; |
|
419 |
|
420 if (!d->engineData) { |
|
421 const QFontCache::Key key(cleanedFontDef(req), script); |
|
422 getEngineData(d, key); |
|
423 } |
|
424 |
|
425 // the cached engineData could have already loaded the engine we want |
|
426 if (d->engineData->engines[script]) |
|
427 fe = d->engineData->engines[script]; |
|
428 |
|
429 if (!fe) { |
|
430 if (qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) { |
|
431 fe = new QTestFontEngine(req.pixelSize); |
|
432 fe->fontDef = req; |
|
433 } else { |
|
434 fe = findFont(script, d, req); |
|
435 } |
|
436 d->engineData->engines[script] = fe; |
|
437 } |
|
438 } |
|
439 |
|
440 QT_END_NAMESPACE |