KoFontGlyphModel::Private Struct Reference

Classes
struct	CodePointInfo
struct	GlyphInfo

Public Member Functions
QMap< QString, KoOpenTypeFeatureInfo >	getOpenTypeTables (FT_FaceSP face, QVector< CodePointInfo > &charMap, QMap< QString, KoOpenTypeFeatureInfo > previousFeatureInfo, bool gpos, bool samplesOnly, QStringList locales, QLatin1String lang=QLatin1String())
	~Private ()=default

Static Public Member Functions
static QVector< CodePointInfo >	charMap (FT_FaceSP face)
static QMap< uint, QVector< GlyphInfo > >	getVSData (FT_FaceSP face)

Public Attributes
QVector< KoUnicodeBlockData >	blocks
QVector< CodePointInfo >	codePoints
QMap< QString, KoOpenTypeFeatureInfo >	featureData
KoOpenTypeFeatureInfoFactory	openTypeFeaturesFactory
KoUnicodeBlockDataFactory	unicodeBlockFactory

Detailed Description

Definition at line 14 of file KoFontGlyphModel.cpp.

Constructor & Destructor Documentation

~Private()

KoFontGlyphModel::Private::~Private ( )

default

Member Function Documentation

charMap()

static QVector< CodePointInfo > KoFontGlyphModel::Private::charMap ( FT_FaceSP face )

inlinestatic

Definition at line 71 of file KoFontGlyphModel.cpp.

                                                          {
        QVector<CodePointInfo> codePoints;
 
        FT_UInt   gindex;
        FT_ULong  charcode = FT_Get_First_Char(face.data(), &gindex);
 
        while (gindex != 0) {
            CodePointInfo cpi;
            cpi.ucs = charcode;
            cpi.glyphIndex = gindex;
            cpi.utfString = QString::fromUcs4(&cpi.ucs, 1);
            cpi.glyphs.append(GlyphInfo(cpi.ucs));
 
            codePoints.append(cpi);
            charcode = FT_Get_Next_Char(face.data(), charcode, &gindex);
        }
 
        return codePoints;
    }

References codePoints, KisLibraryResourcePointer< T, P >::data(), KoFontGlyphModel::Private::CodePointInfo::glyphIndex, KoFontGlyphModel::Private::CodePointInfo::glyphs, KoFontGlyphModel::Private::CodePointInfo::ucs, and KoFontGlyphModel::Private::CodePointInfo::utfString.

getOpenTypeTables()

QMap< QString, KoOpenTypeFeatureInfo > KoFontGlyphModel::Private::getOpenTypeTables ( FT_FaceSP face, QVector< CodePointInfo > & charMap, QMap< QString, KoOpenTypeFeatureInfo > previousFeatureInfo, bool gpos, bool samplesOnly, QStringList locales, QLatin1String lang = QLatin1String() )

inline

Definition at line 116 of file KoFontGlyphModel.cpp.

                                                                                                                                                                                                                                                              {
        // All of this was referenced from Inkscape's OpenTypeUtil.cpp::readOpenTypeGsubTable
        // It has since been reworked to include language testing and alternates.
        QMap<QString, KoOpenTypeFeatureInfo> featureInfo = previousFeatureInfo;
        hb_face_t_sp hbFace(hb_ft_face_create_referenced(face.data()));
        hb_tag_t table = gpos? HB_OT_TAG_GPOS: HB_OT_TAG_GSUB;
        uint targetLanguageIndex = HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX;
 
        QVector<hb_language_t> localeTags;
        Q_FOREACH(const QString locale, locales) {
            QByteArray l(locale.split("_").join("-").toLatin1());
            localeTags.append(hb_language_from_string(l.data(), l.size()));
        }
 
        hb_language_t languageTag = lang.isEmpty()? HB_LANGUAGE_INVALID: hb_language_from_string(lang.data(), lang.size());
        uint scriptCount = hb_ot_layout_table_get_script_tags(hbFace.data(), table, 0, nullptr, nullptr);
        QVector<hb_tag_t> tags;
        QVector<uint> scriptIndices;
        for (uint script = 0; script < scriptCount; script++) {
            uint scriptCount = 1;
            hb_tag_t scriptTag;
            uint scriptIndex;
            hb_ot_layout_table_get_script_tags(hbFace.data(), table, script, &scriptCount, &scriptTag);
            if (!hb_ot_layout_table_select_script(hbFace.data(), table, 1, &scriptTag, &scriptIndex, &scriptTag)) {
                continue;
            }
            scriptIndices.append(scriptIndex);
 
            uint languageCount = hb_ot_layout_script_get_language_tags(hbFace.data(), table, scriptIndex, 0, nullptr, nullptr);
 
            bool foundLanguage = false;
 
            for(uint j = 0; j < languageCount; j++) {
                hb_tag_t langTag;
                uint count = 1;
                hb_ot_layout_script_get_language_tags(hbFace.data(), table, scriptIndex, j, &count, &langTag);
                if (count < 1) continue;
                if (hb_ot_tag_to_language(langTag) == languageTag) {
                    uint languageIndex;
                    if (hb_ot_layout_script_select_language(hbFace.data(), table, scriptIndex, count, &langTag, &languageIndex)) {
                        targetLanguageIndex = languageIndex;
                        foundLanguage = true;
                        break;
                    }
                }
            }
            if (foundLanguage) break;
        }
 
        QHash<quint32, int> glyphToCodepoint;
        for (int i = 0; i< charMap.size(); i++) {
            glyphToCodepoint.insert(charMap.at(i).glyphIndex, i);
        }
 
        for (auto scriptIt = scriptIndices.begin(); scriptIt != scriptIndices.end(); scriptIt++) {
            uint targetScriptIndex = *scriptIt;
            uint featureCount = hb_ot_layout_language_get_feature_tags(hbFace.data(),
                                                                       table,
                                                                       targetScriptIndex,
                                                                       targetLanguageIndex,
                                                                       0, nullptr, nullptr);
            hb_ot_layout_language_get_feature_tags(hbFace.data(), table, targetScriptIndex,
                                                   targetLanguageIndex,
                                                   0, nullptr, nullptr);
            for(uint k = 0; k < featureCount; k++) {
                uint count = 1;
                hb_tag_t features;
                hb_ot_layout_language_get_feature_tags(hbFace.data(), table, targetScriptIndex,
                                                       targetLanguageIndex,
                                                       k, &count, &features);
                if (count < 1) continue;
                tags.append(features);
            }
 
            QVector<uint> featureIndicesProcessed;
            QVector<uint> lookUpsProcessed;
            for (auto tagIt = tags.begin(); tagIt != tags.end(); tagIt++) {
                char c[4];
                hb_tag_to_string(*tagIt, c);
                const QByteArray tagName(c, 4);
                uint featureIndex;
 
 
                bool found = hb_ot_layout_language_find_feature (hbFace.data(), table,
                                                                 targetScriptIndex,
                                                                 targetLanguageIndex,
                                                                 *tagIt,
                                                                 &featureIndex );
 
                if (!found || featureIndicesProcessed.contains(featureIndex)) {
                    continue;
                }
                featureIndicesProcessed.append(featureIndex);
 
                KoOpenTypeFeatureInfo info = featureInfo.value(tagName, openTypeFeaturesFactory.infoByTag(tagName));
                if (!featureInfo.contains(tagName)) {
                    hb_ot_name_id_t labelId = HB_OT_NAME_ID_INVALID;
                    hb_ot_name_id_t toolTipId = HB_OT_NAME_ID_INVALID;
                    hb_ot_name_id_t sampleId = HB_OT_NAME_ID_INVALID;
                    uint namedParameters;
                    hb_ot_name_id_t firstParamId = HB_OT_NAME_ID_INVALID;
 
                    if (hb_ot_layout_feature_get_name_ids(hbFace.data(), table, featureIndex, &labelId, &toolTipId, &sampleId, &namedParameters, &firstParamId)) {
                        QVector<hb_ot_name_id_t> nameIds = {labelId, toolTipId, sampleId};
                        if (firstParamId != HB_OT_NAME_ID_INVALID) {
                            for (uint i = 0; i < namedParameters; i++) {
                                nameIds += firstParamId + i;
                            }
                        }
 
                        for(auto nameId = nameIds.begin(); nameId != nameIds.end(); nameId++) {
                            if (*nameId == HB_OT_NAME_ID_INVALID) {
                                continue;
                            }
                            QVector<hb_language_t> testLang;
                            uint length = 0;
                            if (*nameId == sampleId) {
                                testLang.append(languageTag);
                            } else {
                                testLang = localeTags;
                            }
                            testLang.append(HB_LANGUAGE_INVALID);
                            for (auto tag = testLang.begin(); tag != testLang.end(); tag++) {
                                length = hb_ot_name_get_utf8(hbFace.data(), *nameId, *tag, nullptr, nullptr);
                                if (length > 0) {
                                    length+=1;
                                    break;
                                }
                            }
 
                            std::vector<char> buff(length);
                            hb_ot_name_get_utf8(hbFace.data(), *nameId, languageTag, &length, buff.data());
                            if (length > 0) {
                                const QString nameString = QString::fromUtf8(buff.data(), length);
                                if (*nameId == labelId) {
                                    info.name = nameString;
                                } else if (*nameId == toolTipId) {
                                    info.description = nameString;
                                } else if (*nameId == sampleId) {
                                    info.sample = nameString;
                                } else {
                                    info.namedParameters.append(nameString);
                                }
                            }
                        }
                    }
 
                    featureInfo.insert(tagName, info);
                }
                if (!info.glyphPalette || (samplesOnly && !info.sample.isEmpty())) {
                    continue;
                }
 
                QStringList samples;
                int lookupCount = hb_ot_layout_feature_get_lookups (hbFace.data(), table,
                                                                    featureIndex,
                                                                    0,
                                                                    nullptr,
                                                                    nullptr );
                for (int i = 0; i < lookupCount; ++i) {
                    uint maxCount = 1;
                    uint lookUpIndex = 0;
                    hb_ot_layout_feature_get_lookups (hbFace.data(), table,
                                                      featureIndex,
                                                      i,
                                                      &maxCount,
                                                      &lookUpIndex );
                    if (maxCount < 1 || lookUpsProcessed.contains(lookUpIndex)) {
                        continue;
                    }
 
                    // https://github.com/harfbuzz/harfbuzz/issues/673 suggest against checking the lookups,
                    // but if we don't know the input glyphs, initialization can get really slow.
                    // Given this is run only when the model is created, this should be fine for now.
 
                    hb_set_t_sp glyphsBefore (hb_set_create());
                    hb_set_t_sp glyphsInput (hb_set_create());
                    hb_set_t_sp glyphsAfter (hb_set_create());
                    hb_set_t_sp glyphsOutput (hb_set_create());
 
                    hb_ot_layout_lookup_collect_glyphs (hbFace.data(), table,
                                                        lookUpIndex,
                                                        glyphsBefore.data(),
                                                        glyphsInput.data(),
                                                        glyphsAfter.data(),
                                                        glyphsOutput.data() );
 
                    GlyphInfo gci;
                    gci.type = OpenType;
                    gci.baseString = tagName;
 
                    hb_codepoint_t currentGlyph = HB_SET_VALUE_INVALID;
                    while(hb_set_next(glyphsInput.data(), &currentGlyph)) {
                        if (!glyphToCodepoint.contains(currentGlyph)) continue;
                        const int codePointLocation = glyphToCodepoint.value(currentGlyph);
                        CodePointInfo codePointInfo = charMap.at(codePointLocation);
                        gci.ucs = codePointInfo.ucs;
                        bool addSample = false;
 
                        uint alt_count = hb_ot_layout_lookup_get_glyph_alternates (hbFace.data(),
                                                                                   lookUpIndex, currentGlyph,
                                                                                   0,
                                                                                   nullptr, nullptr);
 
                        if (alt_count > 0) {
                            // 0 is the default value.
                            for(uint j = 1; j < alt_count; ++j) {
                                gci.featureIndex = j;
 
                                bool addToGlyphs = codePointInfo.addToGlyphsIfNotAlready(gci);
                                if (addToGlyphs && !addSample) {
                                    addSample = true;
                                }
                            }
                            info.maxValue = qMax(int(alt_count), info.maxValue);
                        } else {
                            gci.featureIndex = 1;
                            addSample = codePointInfo.addToGlyphsIfNotAlready(gci);
                        }
                        charMap[codePointLocation] = codePointInfo;
                        if (samples.size() < 6 && addSample) {
                            samples.append(QString::fromUcs4(&gci.ucs, 1));
                        }
                        if (samples.size() >= 6 && samplesOnly) {
                            break;
                        }
                    }
 
                    lookUpsProcessed.append(lookUpIndex);
                    if (info.sample.isEmpty() && !samples.isEmpty()) {
                        info.sample = samples.join(" ");
                    }
                    featureInfo.insert(tagName, info);
 
                }
 
            }
        }
 
        return featureInfo;
    }

References KoFontGlyphModel::Private::CodePointInfo::addToGlyphsIfNotAlready(), KoFontGlyphModel::Private::GlyphInfo::baseString, charMap(), KisLibraryResourcePointer< T, P >::data(), KoOpenTypeFeatureInfo::description, KoFontGlyphModel::Private::GlyphInfo::featureIndex, KoFontGlyphModel::featureInfo(), KoOpenTypeFeatureInfo::glyphPalette, KoOpenTypeFeatureInfoFactory::infoByTag(), length(), KoOpenTypeFeatureInfo::maxValue, KoOpenTypeFeatureInfo::name, KoOpenTypeFeatureInfo::namedParameters, KoFontGlyphModel::OpenType, openTypeFeaturesFactory, KoOpenTypeFeatureInfo::sample, KoFontGlyphModel::Private::GlyphInfo::type, KoFontGlyphModel::Private::GlyphInfo::ucs, and KoFontGlyphModel::Private::CodePointInfo::ucs.

getVSData()

static QMap< uint, QVector< GlyphInfo > > KoFontGlyphModel::Private::getVSData ( FT_FaceSP face )

inlinestatic

Definition at line 91 of file KoFontGlyphModel.cpp.

                                                                    {
        QMap<uint, QVector<GlyphInfo>> vsData;
        hb_face_t_sp hbFace(hb_ft_face_create_referenced(face.data()));
        hb_set_t_sp variationSelectors(hb_set_create());
        hb_face_collect_variation_selectors(hbFace.data(), variationSelectors.data());
 
        hb_codepoint_t hbVSPoint = HB_SET_VALUE_INVALID;
 
        while(hb_set_next(variationSelectors.data(), &hbVSPoint)) {
            hb_set_t_sp unicodes(hb_set_create());
 
            hb_face_collect_variation_unicodes(hbFace.data(), hbVSPoint, unicodes.data());
            hb_codepoint_t hbCodePointPoint  = HB_SET_VALUE_INVALID;
            while(hb_set_next(unicodes.data(), &hbCodePointPoint)) {
                QVector<GlyphInfo> glyphs = vsData.value(hbCodePointPoint);
                GlyphInfo gci(hbCodePointPoint);
                gci.type = UnicodeVariationSelector;
                gci.baseString = QString::fromUcs4(&hbVSPoint, 1);
                glyphs.append(gci);
                vsData.insert(hbCodePointPoint, glyphs);
            }
        }
        return vsData;
    }

References KoFontGlyphModel::Private::GlyphInfo::baseString, KisLibraryResourcePointer< T, P >::data(), KoFontGlyphModel::Private::GlyphInfo::type, and KoFontGlyphModel::UnicodeVariationSelector.

Member Data Documentation

blocks

QVector<KoUnicodeBlockData> KoFontGlyphModel::Private::blocks

Definition at line 64 of file KoFontGlyphModel.cpp.

codePoints

QVector<CodePointInfo> KoFontGlyphModel::Private::codePoints

Definition at line 62 of file KoFontGlyphModel.cpp.

featureData

QMap<QString, KoOpenTypeFeatureInfo> KoFontGlyphModel::Private::featureData

Definition at line 63 of file KoFontGlyphModel.cpp.

openTypeFeaturesFactory

KoOpenTypeFeatureInfoFactory KoFontGlyphModel::Private::openTypeFeaturesFactory

Definition at line 65 of file KoFontGlyphModel.cpp.

unicodeBlockFactory

KoUnicodeBlockDataFactory KoFontGlyphModel::Private::unicodeBlockFactory

Definition at line 66 of file KoFontGlyphModel.cpp.

---

The documentation for this struct was generated from the following file:

• libs/flake/text/KoFontGlyphModel.cpp