author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Tue, 02 Feb 2010 00:43:10 +0200 | |
changeset 3 | 41300fa6a67c |
parent 0 | 1918ee327afb |
child 4 | 3b1da2848fc7 |
child 7 | f7bc934e204c |
child 18 | 2f34d5167611 |
permissions | -rw-r--r-- |
0 | 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 |
** |
|
3
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
7 |
** This file is part of the QtGui module of the Qt Toolkit. |
0 | 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 |
#include "qdir.h" |
|
44 |
#include "qfont_p.h" |
|
45 |
#include "qfontengine_s60_p.h" |
|
46 |
#include "qabstractfileengine.h" |
|
47 |
#include "qdesktopservices.h" |
|
48 |
#include "qpixmap_s60_p.h" |
|
49 |
#include "qt_s60_p.h" |
|
50 |
#include "qendian.h" |
|
51 |
#include <private/qcore_symbian_p.h> |
|
52 |
#if defined(QT_NO_FREETYPE) |
|
3
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
53 |
#include <openfont.h> |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
54 |
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
55 |
#include <graphics/openfontrasterizer.h> // COpenFontRasterizer has moved to a new header file |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
56 |
#endif // SYMBIAN_ENABLE_SPLIT_HEADERS |
0 | 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 |
||
3
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
142 |
#ifndef FNTSTORE_H_INLINES_SUPPORT_FMM |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
143 |
/* |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
144 |
Workaround: fntstore.h has an inlined function 'COpenFont* CBitmapFont::OpenFont()' |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
145 |
that returns a private data member. The header will change between SDKs. But Qt has |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
146 |
to build on any SDK version and run on other versions of Symbian OS. |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
147 |
This function performs the needed pointer arithmetic to get the right COpenFont* |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
148 |
*/ |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
149 |
COpenFont* OpenFontFromBitmapFont(const CBitmapFont* aBitmapFont) |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
150 |
{ |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
151 |
const TInt offsetIOpenFont = 92; // '_FOFF(CBitmapFont, iOpenFont)' ..if iOpenFont weren't private |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
152 |
const TUint valueIOpenFont = *(TUint*)PtrAdd(aBitmapFont, offsetIOpenFont); |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
153 |
return (valueIOpenFont & 1) ? |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
154 |
(COpenFont*)PtrAdd(aBitmapFont, valueIOpenFont & ~1) : // New behavior: iOpenFont is offset |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
155 |
(COpenFont*)valueIOpenFont; // Old behavior: iOpenFont is pointer |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
156 |
} |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
157 |
#endif // FNTSTORE_H_INLINES_SUPPORT_FMM |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
158 |
|
0 | 159 |
const QFontEngineS60Extensions *QFontDatabaseS60StoreImplementation::extension(const QString &typeface) const |
160 |
{ |
|
161 |
if (!m_extensions.contains(typeface)) { |
|
162 |
CFont* font = NULL; |
|
163 |
TFontSpec spec(qt_QString2TPtrC(typeface), 1); |
|
164 |
spec.iHeight = 1; |
|
165 |
const TInt err = m_store->GetNearestFontToDesignHeightInPixels(font, spec); |
|
166 |
Q_ASSERT(err == KErrNone && font); |
|
3
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
167 |
const CBitmapFont *bitmapFont = static_cast<CBitmapFont*>(font); |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
168 |
COpenFont *openFont = |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
169 |
#ifdef FNTSTORE_H_INLINES_SUPPORT_FMM |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
170 |
bitmapFont->openFont(); |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
171 |
#else |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
172 |
OpenFontFromBitmapFont(bitmapFont); |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
173 |
#endif // FNTSTORE_H_INLINES_SUPPORT_FMM |
41300fa6a67c
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
174 |
m_extensions.insert(typeface, new QFontEngineS60Extensions(font, openFont)); |
0 | 175 |
} |
176 |
return m_extensions.value(typeface); |
|
177 |
} |
|
178 |
#else |
|
179 |
class QFontEngineFTS60 : public QFontEngineFT |
|
180 |
{ |
|
181 |
public: |
|
182 |
QFontEngineFTS60(const QFontDef &fd); |
|
183 |
}; |
|
184 |
||
185 |
QFontEngineFTS60::QFontEngineFTS60(const QFontDef &fd) |
|
186 |
: QFontEngineFT(fd) |
|
187 |
{ |
|
188 |
default_hint_style = HintFull; |
|
189 |
} |
|
190 |
#endif // defined(QT_NO_FREETYPE) |
|
191 |
||
192 |
/* |
|
193 |
QFontEngineS60::pixelsToPoints, QFontEngineS60::pointsToPixels, QFontEngineMultiS60::QFontEngineMultiS60 |
|
194 |
and QFontEngineMultiS60::QFontEngineMultiS60 should be in qfontengine_s60.cpp. But since also the |
|
195 |
Freetype based font rendering need them, they are here. |
|
196 |
*/ |
|
197 |
qreal QFontEngineS60::pixelsToPoints(qreal pixels, Qt::Orientation orientation) |
|
198 |
{ |
|
199 |
return (orientation == Qt::Horizontal? |
|
200 |
S60->screenDevice()->HorizontalPixelsToTwips(pixels) |
|
201 |
:S60->screenDevice()->VerticalPixelsToTwips(pixels)) / KTwipsPerPoint; |
|
202 |
} |
|
203 |
||
204 |
qreal QFontEngineS60::pointsToPixels(qreal points, Qt::Orientation orientation) |
|
205 |
{ |
|
206 |
const int twips = points * KTwipsPerPoint; |
|
207 |
return orientation == Qt::Horizontal? |
|
208 |
S60->screenDevice()->HorizontalTwipsToPixels(twips) |
|
209 |
:S60->screenDevice()->VerticalTwipsToPixels(twips); |
|
210 |
} |
|
211 |
||
212 |
QFontEngineMultiS60::QFontEngineMultiS60(QFontEngine *first, int script, const QStringList &fallbackFamilies) |
|
213 |
: QFontEngineMulti(fallbackFamilies.size() + 1) |
|
214 |
, m_script(script) |
|
215 |
, m_fallbackFamilies(fallbackFamilies) |
|
216 |
{ |
|
217 |
engines[0] = first; |
|
218 |
first->ref.ref(); |
|
219 |
fontDef = engines[0]->fontDef; |
|
220 |
} |
|
221 |
||
222 |
void QFontEngineMultiS60::loadEngine(int at) |
|
223 |
{ |
|
224 |
Q_ASSERT(at < engines.size()); |
|
225 |
Q_ASSERT(engines.at(at) == 0); |
|
226 |
||
227 |
QFontDef request = fontDef; |
|
228 |
request.styleStrategy |= QFont::NoFontMerging; |
|
229 |
request.family = m_fallbackFamilies.at(at-1); |
|
230 |
engines[at] = QFontDatabase::findFont(m_script, |
|
231 |
/*fontprivate*/0, |
|
232 |
request); |
|
233 |
Q_ASSERT(engines[at]); |
|
234 |
} |
|
235 |
||
236 |
static void initializeDb() |
|
237 |
{ |
|
238 |
QFontDatabasePrivate *db = privateDb(); |
|
239 |
if(!db || db->count) |
|
240 |
return; |
|
241 |
||
242 |
#if defined(QT_NO_FREETYPE) |
|
243 |
if (!db->s60Store) |
|
244 |
db->s60Store = new QFontDatabaseS60StoreImplementation; |
|
245 |
||
246 |
QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock); |
|
247 |
||
248 |
const int numTypeFaces = QS60Data::screenDevice()->NumTypefaces(); |
|
249 |
const QFontDatabaseS60StoreImplementation *store = dynamic_cast<const QFontDatabaseS60StoreImplementation*>(db->s60Store); |
|
250 |
Q_ASSERT(store); |
|
251 |
bool fontAdded = false; |
|
252 |
for (int i = 0; i < numTypeFaces; i++) { |
|
253 |
TTypefaceSupport typefaceSupport; |
|
254 |
QS60Data::screenDevice()->TypefaceSupport(typefaceSupport, i); |
|
255 |
CFont *font; // We have to get a font instance in order to know all the details |
|
256 |
TFontSpec fontSpec(typefaceSupport.iTypeface.iName, 11); |
|
257 |
if (QS60Data::screenDevice()->GetNearestFontInPixels(font, fontSpec) != KErrNone) |
|
258 |
continue; |
|
259 |
if (font->TypeUid() == KCFbsFontUid) { |
|
260 |
TOpenFontFaceAttrib faceAttrib; |
|
261 |
const CFbsFont *cfbsFont = dynamic_cast<const CFbsFont *>(font); |
|
262 |
Q_ASSERT(cfbsFont); |
|
263 |
cfbsFont->GetFaceAttrib(faceAttrib); |
|
264 |
||
265 |
QtFontStyle::Key styleKey; |
|
266 |
styleKey.style = faceAttrib.IsItalic()?QFont::StyleItalic:QFont::StyleNormal; |
|
267 |
styleKey.weight = faceAttrib.IsBold()?QFont::Bold:QFont::Normal; |
|
268 |
||
269 |
QString familyName((const QChar *)typefaceSupport.iTypeface.iName.Ptr(), typefaceSupport.iTypeface.iName.Length()); |
|
270 |
QtFontFamily *family = db->family(familyName, true); |
|
271 |
family->fixedPitch = faceAttrib.IsMonoWidth(); |
|
272 |
QtFontFoundry *foundry = family->foundry(QString(), true); |
|
273 |
QtFontStyle *style = foundry->style(styleKey, true); |
|
274 |
style->smoothScalable = typefaceSupport.iIsScalable; |
|
275 |
style->pixelSize(0, true); |
|
276 |
||
277 |
const QFontEngineS60Extensions *extension = store->extension(familyName); |
|
278 |
const QByteArray os2Table = extension->getSfntTable(MAKE_TAG('O', 'S', '/', '2')); |
|
279 |
const unsigned char* data = reinterpret_cast<const unsigned char*>(os2Table.constData()); |
|
280 |
const unsigned char* ulUnicodeRange = data + 42; |
|
281 |
quint32 unicodeRange[4] = { |
|
282 |
qFromBigEndian<quint32>(ulUnicodeRange), |
|
283 |
qFromBigEndian<quint32>(ulUnicodeRange + 4), |
|
284 |
qFromBigEndian<quint32>(ulUnicodeRange + 8), |
|
285 |
qFromBigEndian<quint32>(ulUnicodeRange + 12) |
|
286 |
}; |
|
287 |
const unsigned char* ulCodePageRange = data + 78; |
|
288 |
quint32 codePageRange[2] = { |
|
289 |
qFromBigEndian<quint32>(ulCodePageRange), |
|
290 |
qFromBigEndian<quint32>(ulCodePageRange + 4) |
|
291 |
}; |
|
292 |
const QList<QFontDatabase::WritingSystem> writingSystems = |
|
293 |
determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange); |
|
294 |
foreach (const QFontDatabase::WritingSystem system, writingSystems) |
|
295 |
family->writingSystems[system] = QtFontFamily::Supported; |
|
296 |
||
297 |
fontAdded = true; |
|
298 |
} |
|
299 |
QS60Data::screenDevice()->ReleaseFont(font); |
|
300 |
} |
|
301 |
||
302 |
Q_ASSERT(fontAdded); |
|
303 |
||
304 |
lock.relock(); |
|
305 |
||
306 |
#else // defined(QT_NO_FREETYPE) |
|
307 |
QDir dir(QDesktopServices::storageLocation(QDesktopServices::FontsLocation)); |
|
308 |
dir.setNameFilters(QStringList() << QLatin1String("*.ttf") |
|
309 |
<< QLatin1String("*.ttc") << QLatin1String("*.pfa") |
|
310 |
<< QLatin1String("*.pfb")); |
|
311 |
for (int i = 0; i < int(dir.count()); ++i) { |
|
312 |
const QByteArray file = QFile::encodeName(dir.absoluteFilePath(dir[i])); |
|
313 |
db->addTTFile(file); |
|
314 |
} |
|
315 |
#endif // defined(QT_NO_FREETYPE) |
|
316 |
} |
|
317 |
||
318 |
static inline void load(const QString &family = QString(), int script = -1) |
|
319 |
{ |
|
320 |
Q_UNUSED(family) |
|
321 |
Q_UNUSED(script) |
|
322 |
initializeDb(); |
|
323 |
} |
|
324 |
||
325 |
static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt) |
|
326 |
{ |
|
327 |
Q_UNUSED(fnt); |
|
328 |
} |
|
329 |
||
330 |
bool QFontDatabase::removeApplicationFont(int handle) |
|
331 |
{ |
|
332 |
Q_UNUSED(handle); |
|
333 |
return false; |
|
334 |
} |
|
335 |
||
336 |
bool QFontDatabase::supportsThreadedFontRendering() |
|
337 |
{ |
|
338 |
return false; |
|
339 |
} |
|
340 |
||
341 |
static |
|
342 |
QFontDef cleanedFontDef(const QFontDef &req) |
|
343 |
{ |
|
344 |
QFontDef result = req; |
|
345 |
if (result.pixelSize <= 0) { |
|
346 |
result.pixelSize = QFontEngineS60::pointsToPixels(qMax(qreal(1.0), result.pointSize)); |
|
347 |
result.pointSize = 0; |
|
348 |
} |
|
349 |
return result; |
|
350 |
} |
|
351 |
||
352 |
QFontEngine *QFontDatabase::findFont(int script, const QFontPrivate *, const QFontDef &req) |
|
353 |
{ |
|
354 |
const QFontCache::Key key(cleanedFontDef(req), script); |
|
355 |
||
356 |
if (!privateDb()->count) |
|
357 |
initializeDb(); |
|
358 |
||
359 |
QFontEngine *fe = QFontCache::instance()->findEngine(key); |
|
360 |
if (!fe) { |
|
361 |
// Making sure that fe->fontDef.family will be an existing font. |
|
362 |
initializeDb(); |
|
363 |
QFontDatabasePrivate *db = privateDb(); |
|
364 |
QtFontDesc desc; |
|
365 |
QList<int> blacklistedFamilies; |
|
366 |
match(script, req, req.family, QString(), -1, &desc, blacklistedFamilies); |
|
367 |
if (!desc.family) // falling back to application font |
|
368 |
desc.family = db->family(QApplication::font().defaultFamily()); |
|
369 |
Q_ASSERT(desc.family); |
|
370 |
||
371 |
// Making sure that desc.family supports the requested script |
|
372 |
QtFontDesc mappedDesc; |
|
373 |
bool supportsScript = false; |
|
374 |
do { |
|
375 |
match(script, req, QString(), QString(), -1, &mappedDesc, blacklistedFamilies); |
|
376 |
if (mappedDesc.family == desc.family) { |
|
377 |
supportsScript = true; |
|
378 |
break; |
|
379 |
} |
|
380 |
blacklistedFamilies.append(mappedDesc.familyIndex); |
|
381 |
} while (mappedDesc.family); |
|
382 |
if (!supportsScript) { |
|
383 |
blacklistedFamilies.clear(); |
|
384 |
match(script, req, QString(), QString(), -1, &mappedDesc, blacklistedFamilies); |
|
385 |
if (mappedDesc.family) |
|
386 |
desc = mappedDesc; |
|
387 |
} |
|
388 |
||
389 |
const QString fontFamily = desc.family->name; |
|
390 |
QFontDef request = req; |
|
391 |
request.family = fontFamily; |
|
392 |
#if defined(QT_NO_FREETYPE) |
|
393 |
const QFontDatabaseS60StoreImplementation *store = dynamic_cast<const QFontDatabaseS60StoreImplementation*>(db->s60Store); |
|
394 |
Q_ASSERT(store); |
|
395 |
const QFontEngineS60Extensions *extension = store->extension(fontFamily); |
|
396 |
fe = new QFontEngineS60(request, extension); |
|
397 |
#else |
|
398 |
QFontEngine::FaceId faceId; |
|
399 |
const QtFontFamily * const reqQtFontFamily = db->family(fontFamily); |
|
400 |
faceId.filename = reqQtFontFamily->fontFilename; |
|
401 |
faceId.index = reqQtFontFamily->fontFileIndex; |
|
402 |
||
403 |
QFontEngineFTS60 *fte = new QFontEngineFTS60(cleanedFontDef(request)); |
|
404 |
if (fte->init(faceId, true, QFontEngineFT::Format_A8)) |
|
405 |
fe = fte; |
|
406 |
else |
|
407 |
delete fte; |
|
408 |
#endif |
|
409 |
||
410 |
Q_ASSERT(fe); |
|
411 |
if (script == QUnicodeTables::Common |
|
412 |
&& !(req.styleStrategy & QFont::NoFontMerging) |
|
413 |
&& !fe->symbol) { |
|
414 |
||
415 |
QStringList commonFonts; |
|
416 |
for (int ws = 1; ws < QFontDatabase::WritingSystemsCount; ++ws) { |
|
417 |
if (scriptForWritingSystem[ws] != script) |
|
418 |
continue; |
|
419 |
for (int i = 0; i < db->count; ++i) { |
|
420 |
if (db->families[i]->writingSystems[ws] & QtFontFamily::Supported) |
|
421 |
commonFonts.append(db->families[i]->name); |
|
422 |
} |
|
423 |
} |
|
424 |
||
425 |
// Hack: Prioritize .ccc fonts |
|
426 |
const QString niceEastAsianFont(QLatin1String("Sans MT 936_S60")); |
|
427 |
if (commonFonts.removeAll(niceEastAsianFont) > 0) |
|
428 |
commonFonts.prepend(niceEastAsianFont); |
|
429 |
||
430 |
fe = new QFontEngineMultiS60(fe, script, commonFonts); |
|
431 |
} |
|
432 |
} |
|
433 |
fe->ref.ref(); |
|
434 |
QFontCache::instance()->insertEngine(key, fe); |
|
435 |
return fe; |
|
436 |
} |
|
437 |
||
438 |
void QFontDatabase::load(const QFontPrivate *d, int script) |
|
439 |
{ |
|
440 |
QFontEngine *fe = 0; |
|
441 |
QFontDef req = d->request; |
|
442 |
||
443 |
if (!d->engineData) { |
|
444 |
const QFontCache::Key key(cleanedFontDef(req), script); |
|
445 |
getEngineData(d, key); |
|
446 |
} |
|
447 |
||
448 |
// the cached engineData could have already loaded the engine we want |
|
449 |
if (d->engineData->engines[script]) |
|
450 |
fe = d->engineData->engines[script]; |
|
451 |
||
452 |
if (!fe) { |
|
453 |
if (qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) { |
|
454 |
fe = new QTestFontEngine(req.pixelSize); |
|
455 |
fe->fontDef = req; |
|
456 |
} else { |
|
457 |
fe = findFont(script, d, req); |
|
458 |
} |
|
459 |
d->engineData->engines[script] = fe; |
|
460 |
} |
|
461 |
} |
|
462 |
||
463 |
QT_END_NAMESPACE |