SkFontHost_linux.cpp revision 33068c19f1b8c18f000c18935ad11f1082534b5a 
1/*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkFontHost.h"
9#include "SkFontHost_FreeType_common.h"
10#include "SkFontDescriptor.h"
11#include "SkFontMgr.h"
12#include "SkDescriptor.h"
13#include "SkOSFile.h"
14#include "SkPaint.h"
15#include "SkString.h"
16#include "SkStream.h"
17#include "SkThread.h"
18#include "SkTSearch.h"
19#include "SkTypefaceCache.h"
20#include "SkTArray.h"
21
22#include <limits>
23
24#ifndef SK_FONT_FILE_PREFIX
25#    define SK_FONT_FILE_PREFIX "/usr/share/fonts/"
26#endif
27
28///////////////////////////////////////////////////////////////////////////////
29
30/** The base SkTypeface implementation for the custom font manager. */
31class SkTypeface_Custom : public SkTypeface_FreeType {
32public:
33    SkTypeface_Custom(const SkFontStyle& style, bool isFixedPitch,
34                      bool sysFont, const SkString familyName, int index)
35        : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
36        , fIsSysFont(sysFont), fFamilyName(familyName), fIndex(index)
37    { }
38
39    bool isSysFont() const { return fIsSysFont; }
40
41    virtual const char* getUniqueString() const = 0;
42
43protected:
44    virtual void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
45        *familyName = fFamilyName;
46    }
47
48    virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const SK_OVERRIDE {
49        desc->setFamilyName(fFamilyName.c_str());
50        desc->setFontFileName(this->getUniqueString());
51        desc->setFontIndex(fIndex);
52        *isLocal = !this->isSysFont();
53    }
54
55    int getIndex() const { return fIndex; }
56
57private:
58    const bool fIsSysFont;
59    const SkString fFamilyName;
60    const int fIndex;
61
62    typedef SkTypeface_FreeType INHERITED;
63};
64
65/** The empty SkTypeface implementation for the custom font manager.
66 *  Used as the last resort fallback typeface.
67 */
68class SkTypeface_Empty : public SkTypeface_Custom {
69public:
70    SkTypeface_Empty() : INHERITED(SkFontStyle(), false, true, SkString(), 0) {}
71
72    virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
73
74protected:
75    virtual SkStream* onOpenStream(int*) const SK_OVERRIDE { return NULL; }
76
77private:
78    typedef SkTypeface_Custom INHERITED;
79};
80
81/** The stream SkTypeface implementation for the custom font manager. */
82class SkTypeface_Stream : public SkTypeface_Custom {
83public:
84    SkTypeface_Stream(const SkFontStyle& style, bool isFixedPitch, bool sysFont,
85                      const SkString familyName, SkStream* stream, int index)
86        : INHERITED(style, isFixedPitch, sysFont, familyName, index)
87        , fStream(SkRef(stream))
88    { }
89
90    virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
91
92protected:
93    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
94        *ttcIndex = this->getIndex();
95        return fStream->duplicate();
96    }
97
98private:
99    const SkAutoTUnref<const SkStream> fStream;
100
101    typedef SkTypeface_Custom INHERITED;
102};
103
104/** The file SkTypeface implementation for the custom font manager. */
105class SkTypeface_File : public SkTypeface_Custom {
106public:
107    SkTypeface_File(const SkFontStyle& style, bool isFixedPitch, bool sysFont,
108                    const SkString familyName, const char path[], int index)
109        : INHERITED(style, isFixedPitch, sysFont, familyName, index)
110        , fPath(path)
111    { }
112
113    virtual const char* getUniqueString() const SK_OVERRIDE {
114        const char* str = strrchr(fPath.c_str(), '/');
115        if (str) {
116            str += 1;   // skip the '/'
117        }
118        return str;
119    }
120
121protected:
122    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
123        *ttcIndex = this->getIndex();
124        return SkStream::NewFromFile(fPath.c_str());
125    }
126
127private:
128    SkString fPath;
129
130    typedef SkTypeface_Custom INHERITED;
131};
132
133///////////////////////////////////////////////////////////////////////////////
134
135/**
136 *  SkFontStyleSet_Custom
137 *
138 *  This class is used by SkFontMgr_Custom to hold SkTypeface_Custom families.
139 */
140class SkFontStyleSet_Custom : public SkFontStyleSet {
141public:
142    explicit SkFontStyleSet_Custom(const SkString familyName) : fFamilyName(familyName) { }
143
144    virtual int count() SK_OVERRIDE {
145        return fStyles.count();
146    }
147
148    virtual void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
149        SkASSERT(index < fStyles.count());
150        bool bold = fStyles[index]->isBold();
151        bool italic = fStyles[index]->isItalic();
152        *style = SkFontStyle(bold ? SkFontStyle::kBold_Weight : SkFontStyle::kNormal_Weight,
153                             SkFontStyle::kNormal_Width,
154                             italic ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant);
155        name->reset();
156    }
157
158    virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
159        SkASSERT(index < fStyles.count());
160        return SkRef(fStyles[index].get());
161    }
162
163    static int match_score(const SkFontStyle& pattern, const SkFontStyle& candidate) {
164        int score = 0;
165        score += (pattern.width() - candidate.width()) * 100;
166        score += (pattern.isItalic() == candidate.isItalic()) ? 0 : 1000;
167        score += pattern.weight() - candidate.weight();
168        return score;
169    }
170
171    virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
172        if (0 == fStyles.count()) {
173            return NULL;
174        }
175
176        SkTypeface_Custom* closest = fStyles[0];
177        int minScore = std::numeric_limits<int>::max();
178        for (int i = 0; i < fStyles.count(); ++i) {
179            bool bold = fStyles[i]->isBold();
180            bool italic = fStyles[i]->isItalic();
181            SkFontStyle style = SkFontStyle(bold ? SkFontStyle::kBold_Weight
182                                                 : SkFontStyle::kNormal_Weight,
183                                            SkFontStyle::kNormal_Width,
184                                            italic ? SkFontStyle::kItalic_Slant
185                                                   : SkFontStyle::kUpright_Slant);
186
187            int score = match_score(pattern, style);
188            if (score < minScore) {
189                closest = fStyles[i];
190                minScore = score;
191            }
192        }
193        return SkRef(closest);
194    }
195
196private:
197    SkTArray<SkAutoTUnref<SkTypeface_Custom>, true> fStyles;
198    SkString fFamilyName;
199
200    void appendTypeface(SkTypeface_Custom* typeface) {
201        fStyles.push_back().reset(typeface);
202    }
203
204    friend class SkFontMgr_Custom;
205};
206
207/**
208 *  SkFontMgr_Custom
209 *
210 *  This class is essentially a collection of SkFontStyleSet_Custom,
211 *  one SkFontStyleSet_Custom for each family. This class may be modified
212 *  to load fonts from any source by changing the initialization.
213 */
214class SkFontMgr_Custom : public SkFontMgr {
215public:
216    explicit SkFontMgr_Custom(const char* dir) {
217        this->load_system_fonts(dir);
218    }
219
220protected:
221    virtual int onCountFamilies() const SK_OVERRIDE {
222        return fFamilies.count();
223    }
224
225    virtual void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
226        SkASSERT(index < fFamilies.count());
227        familyName->set(fFamilies[index]->fFamilyName);
228    }
229
230    virtual SkFontStyleSet_Custom* onCreateStyleSet(int index) const SK_OVERRIDE {
231        SkASSERT(index < fFamilies.count());
232        return SkRef(fFamilies[index].get());
233    }
234
235    virtual SkFontStyleSet_Custom* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
236        for (int i = 0; i < fFamilies.count(); ++i) {
237            if (fFamilies[i]->fFamilyName.equals(familyName)) {
238                return SkRef(fFamilies[i].get());
239            }
240        }
241        return NULL;
242    }
243
244    virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
245                                           const SkFontStyle& fontStyle) const SK_OVERRIDE
246    {
247        SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
248        return sset->matchStyle(fontStyle);
249    }
250
251    virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
252                                                    const char* bcp47[], int bcp47Count,
253                                                    SkUnichar character) const SK_OVERRIDE
254    {
255        return NULL;
256    }
257
258    virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
259                                         const SkFontStyle& fontStyle) const SK_OVERRIDE
260    {
261        for (int i = 0; i < fFamilies.count(); ++i) {
262            for (int j = 0; j < fFamilies[i]->fStyles.count(); ++j) {
263                if (fFamilies[i]->fStyles[j] == familyMember) {
264                    return fFamilies[i]->matchStyle(fontStyle);
265                }
266            }
267        }
268        return NULL;
269    }
270
271    virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
272        SkAutoTUnref<SkStream> stream(new SkMemoryStream(data));
273        return this->createFromStream(stream, ttcIndex);
274    }
275
276    virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) const SK_OVERRIDE {
277        if (NULL == stream || stream->getLength() <= 0) {
278            SkDELETE(stream);
279            return NULL;
280        }
281
282        bool isFixedPitch;
283        SkFontStyle style;
284        SkString name;
285        if (fScanner.scanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
286            return SkNEW_ARGS(SkTypeface_Stream, (style, isFixedPitch, false, name,
287                                                  stream, ttcIndex));
288        } else {
289            return NULL;
290        }
291    }
292
293    virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
294        SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
295        return stream.get() ? this->createFromStream(stream, ttcIndex) : NULL;
296    }
297
298    virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
299                                               unsigned styleBits) const SK_OVERRIDE
300    {
301        SkTypeface::Style oldStyle = (SkTypeface::Style)styleBits;
302        SkFontStyle style = SkFontStyle(oldStyle & SkTypeface::kBold
303                                                 ? SkFontStyle::kBold_Weight
304                                                 : SkFontStyle::kNormal_Weight,
305                                        SkFontStyle::kNormal_Width,
306                                        oldStyle & SkTypeface::kItalic
307                                                 ? SkFontStyle::kItalic_Slant
308                                                 : SkFontStyle::kUpright_Slant);
309        SkTypeface* tf = NULL;
310
311        if (familyName) {
312            tf = this->onMatchFamilyStyle(familyName, style);
313        }
314
315        if (NULL == tf) {
316            tf = gDefaultFamily->matchStyle(style);
317        }
318
319        return SkSafeRef(tf);
320    }
321
322private:
323
324    void load_directory_fonts(const SkString& directory, const char* suffix) {
325        SkOSFile::Iter iter(directory.c_str(), suffix);
326        SkString name;
327
328        while (iter.next(&name, false)) {
329            SkString filename(SkOSPath::Join(directory.c_str(), name.c_str()));
330            SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(filename.c_str()));
331            if (!stream.get()) {
332                SkDebugf("---- failed to open <%s>\n", filename.c_str());
333                continue;
334            }
335
336            int numFaces;
337            if (!fScanner.recognizedFont(stream, &numFaces)) {
338                SkDebugf("---- failed to open <%s> as a font\n", filename.c_str());
339                continue;
340            }
341
342            for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
343                bool isFixedPitch;
344                SkString realname;
345                SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
346                if (!fScanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch)) {
347                    SkDebugf("---- failed to open <%s> <%d> as a font\n",
348                             filename.c_str(), faceIndex);
349                    continue;
350                }
351
352                SkTypeface_Custom* tf = SkNEW_ARGS(SkTypeface_File, (
353                                                    style,
354                                                    isFixedPitch,
355                                                    true,  // system-font (cannot delete)
356                                                    realname,
357                                                    filename.c_str(), 0));
358
359                SkFontStyleSet_Custom* addTo = this->onMatchFamily(realname.c_str());
360                if (NULL == addTo) {
361                    addTo = new SkFontStyleSet_Custom(realname);
362                    fFamilies.push_back().reset(addTo);
363                }
364                addTo->appendTypeface(tf);
365            }
366        }
367
368        SkOSFile::Iter dirIter(directory.c_str());
369        while (dirIter.next(&name, true)) {
370            if (name.startsWith(".")) {
371                continue;
372            }
373            SkString dirname(SkOSPath::Join(directory.c_str(), name.c_str()));
374            load_directory_fonts(dirname, suffix);
375        }
376    }
377
378    void load_system_fonts(const char* dir) {
379        SkString baseDirectory(dir);
380        load_directory_fonts(baseDirectory, ".ttf");
381        load_directory_fonts(baseDirectory, ".ttc");
382        load_directory_fonts(baseDirectory, ".otf");
383        load_directory_fonts(baseDirectory, ".pfb");
384
385        if (fFamilies.empty()) {
386            SkFontStyleSet_Custom* family = new SkFontStyleSet_Custom(SkString());
387            fFamilies.push_back().reset(family);
388            family->appendTypeface(SkNEW(SkTypeface_Empty));
389        }
390
391        // Try to pick a default font.
392        static const char* gDefaultNames[] = {
393            "Arial", "Verdana", "Times New Roman", "Droid Sans", NULL
394        };
395        for (size_t i = 0; i < SK_ARRAY_COUNT(gDefaultNames); ++i) {
396            SkFontStyleSet_Custom* set = this->onMatchFamily(gDefaultNames[i]);
397            if (NULL == set) {
398                continue;
399            }
400
401            SkTypeface* tf = set->matchStyle(SkFontStyle(SkFontStyle::kNormal_Weight,
402                                                         SkFontStyle::kNormal_Width,
403                                                         SkFontStyle::kUpright_Slant));
404            if (NULL == tf) {
405                continue;
406            }
407
408            gDefaultFamily = set;
409            gDefaultNormal = tf;
410            break;
411        }
412        if (NULL == gDefaultNormal) {
413            gDefaultFamily = fFamilies[0];
414            gDefaultNormal = gDefaultFamily->fStyles[0];
415        }
416    }
417
418    SkTArray<SkAutoTUnref<SkFontStyleSet_Custom>, true> fFamilies;
419    SkFontStyleSet_Custom* gDefaultFamily;
420    SkTypeface* gDefaultNormal;
421    SkTypeface_FreeType::Scanner fScanner;
422};
423
424SkFontMgr* SkFontMgr::Factory() {
425    return new SkFontMgr_Custom(SK_FONT_FILE_PREFIX);
426}
427