KoFFWWSConverter Class Reference

The KoFFWWSConverter class This class takes fontconfig patterns and tries to sort them into a hierarchy of typographic/wws/font files font families, as well as retrieving all sorts of information to display in the GUI. More...

#include <KoFFWWSConverter.h>

Classes
struct	FontFileEntry
struct	Private

Public Member Functions
bool	addFontFromFile (const QString &filename, const int index, FT_LibrarySP freeTypeLibrary)
bool	addFontFromPattern (const FcPattern *pattern, FT_LibrarySP freeTypeLibrary)
	Add a font from a fontconfig pattern.
void	addGenericFamily (const QString &name)
	This adds a CSS generic family. Call this before sortIntoWWSFamilies.
void	addSupportedLanguagesByFile (const QString &filename, const int index, const QList< QLocale > &supportedLanguages, FcCharSet *set)
QVector< FontFileEntry >	candidatesForCssValues (const KoCSSFontInfo info, quint32 xRes=72, quint32 yRes=72) const
	candidatesForCssValues Search the nodes for the most appropriate font for the given css values. We want to give these preferential treatment to whatever fontconfig matches for us.
QList< KoFontFamilyWWSRepresentation >	collectFamilies () const
	Collects all WWSFamilies (that is, CSS compatible groupings of font files) and return them.
void	debugInfo () const
	Print out the font family hierarchy into the debug output.
	KoFFWWSConverter ()
std::optional< KoFontFamilyWWSRepresentation >	representationByFamilyName (const QString &familyName) const
	Gets a single WWSFamily representation for a given CSS Family Name, used by KoFontStorage.
void	sortIntoWWSFamilies ()
	Sort any straggling fonts into WWSFamilies.
std::optional< QString >	wwsNameByFamilyName (const QString familyName) const
	Used to find the closest corresponding resource when the family name doesn't match.
	~KoFFWWSConverter ()

Private Attributes
QScopedPointer< Private >	d

Detailed Description

The KoFFWWSConverter class This class takes fontconfig patterns and tries to sort them into a hierarchy of typographic/wws/font files font families, as well as retrieving all sorts of information to display in the GUI.

This is necessary because by default FontConfig patterns don't differentiate between fonts family names, which means that some fonts are not selectable by CSS values alone.

Definition at line 57 of file KoFFWWSConverter.h.

Constructor & Destructor Documentation

KoFFWWSConverter()

KoFFWWSConverter::KoFFWWSConverter

(

)

Definition at line 259 of file KoFFWWSConverter.cpp.

    : d(new Private())
{
 
}

~KoFFWWSConverter()

KoFFWWSConverter::~KoFFWWSConverter

(

)

Definition at line 265 of file KoFFWWSConverter.cpp.

{
}

Member Function Documentation

addFontFromFile()

bool KoFFWWSConverter::addFontFromFile	(	const QString &	filename,
		const int	index,
		FT_LibrarySP	freeTypeLibrary )

Add a font from a filename and index. This will use freetype and harfbuzz to figure out the family name(s), styles and other font features.

< twip is 'Twenty-in-point';

Definition at line 341 of file KoFFWWSConverter.cpp.

                                                                                                             {
 
    FontFamilyNode fontFamily;
    fontFamily.fileName = filename;
    fontFamily.fileIndex = index;
    for (auto it = d->fontFamilyCollection.begin(); it != d->fontFamilyCollection.end(); it++) {
        if (it->fileName == fontFamily.fileName && it->fileIndex == fontFamily.fileIndex) {
            return true;
        }
    }
 
    FT_Face f = nullptr;
    FT_FaceSP face;
    QByteArray utfData = fontFamily.fileName.toUtf8();
    if (FT_New_Face(freeTypeLibrary.data(), utfData.data(), fontFamily.fileIndex, &f) == 0) {
        face.reset(f);
    } else {
        return false;
    }
 
    fontFamily.fontFamily = face->family_name;
    fontFamily.fontStyle = face->style_name;
    fontFamily.lastModified = QFileInfo(fontFamily.fileName).lastModified();
    FontFamilyNode typographicFamily;
    FontFamilyNode wwsFamily;
    bool isWWSFamilyWithoutName = false;
 
    if (!FT_IS_SFNT(face.data())) {
        fontFamily.type = FT_IS_SCALABLE(face.data())? KoSvgText::Type1FontType: KoSvgText::BDFFontType;
 
        fontFamily.isItalic = face->style_flags & FT_STYLE_FLAG_ITALIC;
        if (face->style_flags & FT_STYLE_FLAG_BOLD) {
            fontFamily.axes.insert(WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(700));
        } else {
            fontFamily.axes.insert(WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(400));
        }
 
        for (int i=0; i< face->num_fixed_sizes; i++) {
            // 64 = Freetype pixel
            fontFamily.pixelSizes.insert((face->available_sizes[i].size / 64.0), {fontFamily.fileName});
        }
    } else {
        fontFamily.type = KoSvgText::OpenTypeFontType;
        hb_face_t_sp hbFace(hb_ft_face_create_referenced(face.data()));
        hb_font_t_sp hbFont(hb_ft_font_create_referenced(face.data()));
 
        // Retrieve width, weight and slant data.
 
        fontFamily.axes.insert(WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(hb_style_get_value(hbFont.data(), HB_STYLE_TAG_WEIGHT)));
        fontFamily.axes.insert(WIDTH_TAG, KoSvgText::FontFamilyAxis::widthAxis(hb_style_get_value(hbFont.data(), HB_STYLE_TAG_WIDTH)));
        fontFamily.isItalic = hb_style_get_value(hbFont.data(), HB_STYLE_TAG_ITALIC) > 0;
        //fontFamily.isOblique = hb_style_get_value(hbFont.data(), HB_STYLE_TAG_SLANT_ANGLE) != 0;
 
        TT_OS2 *os2Table = nullptr;
        os2Table = (TT_OS2*)FT_Get_Sfnt_Table(face.data(), FT_SFNT_OS2);
        if (os2Table) {
 
            fontFamily.isOblique = os2Table->fsSelection & OS2_OBLIQUE;
 
            if (os2Table->fsSelection & OS2_REGULAR) {
                fontFamily.isItalic = false;
                fontFamily.isOblique = false;
            }
 
            if (os2Table->version >= 5) {
                FontFamilySizeInfo sizeInfo;
                const qreal twip = 0.05; 
                sizeInfo.high = os2Table->usUpperOpticalPointSize * twip;
                sizeInfo.low = os2Table->usLowerOpticalPointSize * twip;
                sizeInfo.os2table = true;
                sizeInfo.isSet = true;
                fontFamily.sizeInfo = sizeInfo;
            }
            isWWSFamilyWithoutName = (os2Table->fsSelection & OS2_WWS);
        }
 
 
        // retrieve gpos size data...
        uint designSize;
        uint subFamilyId;
        uint rangeStart;
        uint rangeEnd;
        hb_ot_name_id_t sizeNameId;
        if (hb_ot_layout_get_size_params(hbFace.data(), &designSize, &subFamilyId, &sizeNameId, &rangeStart, &rangeEnd)) {
            FontFamilySizeInfo sizeInfo;
            qreal tenth = 0.1;
            sizeInfo.low = rangeStart * tenth;
            sizeInfo.high = rangeEnd * tenth;
            sizeInfo.subFamilyID = subFamilyId;
            sizeInfo.designSize = designSize * tenth;
            sizeInfo.isSet = true;
            fontFamily.sizeInfo = sizeInfo;
        }
 
        // retrieve axis data...
        // Would also be good if we could read the STAT table for more info, but we cannot as there's no API for that in harfbuzz.
 
        QHash<hb_ot_name_id_t, QString> axisNameIDs;
        QVector<hb_ot_name_id_t> instanceNameIDs;
        if (hb_ot_var_has_data(hbFace.data())) {
            fontFamily.isVariable = true;
            uint count = hb_ot_var_get_axis_count(hbFace.data());
            uint maxInfos = 1;
            QStringList axesTags;
            for (uint i = 0; i < count; i++) {
                KoSvgText::FontFamilyAxis axisInfo;
                hb_ot_var_axis_info_t axis;
                hb_ot_var_get_axis_infos(hbFace.data(), i, &maxInfos, &axis);
                axisInfo.min = axis.min_value;
                axisInfo.max = axis.max_value;
                axisInfo.value = axis.default_value;
                axisInfo.axisHidden = axis.flags & HB_OT_VAR_AXIS_FLAG_HIDDEN;
                char buff[4];
                hb_tag_to_string(axis.tag, buff);
                axisInfo.tag = QString::fromLatin1(buff, 4);
                axisNameIDs.insert(axis.name_id, axisInfo.tag);
                axisInfo.variableAxis = true;
                fontFamily.axes.insert(axisInfo.tag, axisInfo);
                axesTags.append(axisInfo.tag);
            }
            count = hb_ot_var_get_named_instance_count (hbFace.data());
            for (uint i = 0; i < count; i++) {
                QHash<QString, float> instanceCoords;
                uint coordLength = axesTags.size();
                std::vector<float> coordinate(coordLength);
                hb_ot_var_named_instance_get_design_coords (hbFace.data(), i, &coordLength, coordinate.data());
                for (uint j =0; j < coordLength; j++ ){
                    instanceCoords.insert(axesTags.value(j), coordinate[j]);
                }
                KoSvgText::FontFamilyStyleInfo style;
                style.instanceCoords = instanceCoords;
                instanceNameIDs.append(hb_ot_var_named_instance_get_subfamily_name_id(hbFace.data(), i));
                fontFamily.styleInfo.append(style);
            }
        }
 
        // Get some basic color data.
        fontFamily.colorBitMap = hb_ot_color_has_png(hbFace.data());
        fontFamily.colorSVG = hb_ot_color_has_svg(hbFace.data());
        fontFamily.colorClrV0 = hb_ot_color_has_layers(hbFace.data());
        //fontFamily.colorClrV1 = hb_ot_color_has_paint(hbFace);
        wwsFamily.colorBitMap = fontFamily.colorBitMap;
        wwsFamily.colorSVG = fontFamily.colorSVG;
        wwsFamily.colorClrV0 = fontFamily.colorClrV0;
 
        uint numEntries = 0;
        const hb_ot_name_entry_t *entries = hb_ot_name_list_names(hbFace.data(), &numEntries);
 
        QHash<QLocale, QString> ribbiFamilyNames;
        QHash<QLocale, QString> ribbiStyleNames;
        QHash<QLocale, QString> WWSFamilyNames;
        QHash<QLocale, QString> WWSStyleNames;
        QHash<QLocale, QString> typographicFamilyNames;
        QHash<QLocale, QString> typographicStyleNames;
        QHash<QLocale, QString> fullNames;
        for (uint i = 0; i < numEntries; i++) {
            hb_ot_name_entry_t entry = entries[i];
            QString lang(hb_language_to_string(entry.language));
            QLocale locale(lang);
            uint length = hb_ot_name_get_utf8(hbFace.data(), entry.name_id, entry.language, nullptr, nullptr)+1;
            std::vector<char> buff(length);
            hb_ot_name_get_utf8(hbFace.data(), entry.name_id, entry.language, &length, buff.data());
            QString name = QString::fromUtf8(buff.data(), length);
            if (name.isEmpty()) continue;
 
            if (entry.name_id == HB_OT_NAME_ID_FONT_FAMILY) {
                ribbiFamilyNames.insert(locale, name);
            } else if (entry.name_id == HB_OT_NAME_ID_TYPOGRAPHIC_FAMILY) {
                typographicFamilyNames.insert(locale, name);
            } else if (entry.name_id == HB_OT_NAME_ID_WWS_FAMILY) {
                WWSFamilyNames.insert(locale, name);
            } else if (entry.name_id == HB_OT_NAME_ID_FONT_SUBFAMILY) {
                ribbiStyleNames.insert(locale, name);
            } else if (entry.name_id == HB_OT_NAME_ID_TYPOGRAPHIC_SUBFAMILY) {
                typographicStyleNames.insert(locale, name);
            } else if (entry.name_id == HB_OT_NAME_ID_WWS_SUBFAMILY) {
                WWSStyleNames.insert(locale, name);
            } else if (entry.name_id == HB_OT_NAME_ID_FULL_NAME) {
                fullNames.insert(locale, name);
            } else if (entry.name_id > 0) { // Fonts made by Adobe seem to use the copyright id (0) as the input when the given value is empty.
                if (axisNameIDs.keys().contains(entry.name_id)) {
                    fontFamily.axes[axisNameIDs.value(entry.name_id)].localizedLabels.insert(locale, name);
                } else if (entry.name_id == sizeNameId) {
                    fontFamily.sizeInfo.localizedLabels.insert(locale, name);
                } else if (instanceNameIDs.contains(entry.name_id)) {
                    int idx = instanceNameIDs.indexOf(entry.name_id);
                    fontFamily.styleInfo[idx].localizedLabels.insert(locale, name);
                }
            }
        }
        QLocale english(QLocale::English);
        if (!typographicFamilyNames.isEmpty()) {
            typographicFamily.fontFamily = typographicFamilyNames.value(english, typographicFamilyNames.values().first());
            typographicFamily.localizedFontFamilies = typographicFamilyNames;
        }
        fontFamily.localizedTypographicStyle = typographicStyleNames;
        if (!ribbiFamilyNames.isEmpty()) {
            fontFamily.fontFamily = ribbiFamilyNames.value(english, ribbiFamilyNames.values().first());
            fontFamily.localizedFontFamilies = ribbiFamilyNames;
        }
        // Second check is a hack to avoid issues with the css test fonts. Why they are configure this way, beats me.
        // Either way, if the fullname, which has 100% priority is the name as typographic name (which is tested last)
        // the font search will only select the node with this fullname, which we don't want.
        if (!fullNames.isEmpty() && fullNames != typographicFamilyNames) {
            fontFamily.localizedFullName = fullNames;
        }
        if (!ribbiStyleNames.isEmpty()) {
            fontFamily.fontStyle = ribbiStyleNames.value(english, ribbiStyleNames.values().first());
            fontFamily.localizedFontStyle = ribbiStyleNames;
        }
        if (!WWSFamilyNames.isEmpty()) {
            wwsFamily.fontFamily = WWSFamilyNames.value(english, WWSFamilyNames.values().first());
            wwsFamily.localizedFontFamilies = WWSFamilyNames;
        }
        fontFamily.localizedWWSStyle = WWSStyleNames;
    }
 
    if (fontFamily.fontFamily.isEmpty()) {
        fontFamily.fontFamily = QFileInfo(fontFamily.fileName).baseName();
    }
    if (typographicFamily.fontFamily.isEmpty()) {
        typographicFamily.fontFamily = fontFamily.fontFamily;
    }
    wwsFamily.isVariable = fontFamily.isVariable;
    wwsFamily.type = fontFamily.type;
    typographicFamily.type = typographicFamily.type;
 
    if (typographicFamily.fontFamily.isEmpty() && fontFamily.fontFamily.isEmpty()) {
        d->fontFamilyCollection.insert(d->fontFamilyCollection.childEnd(), fontFamily);
    } else {
        // find potential typographic family
        auto it = d->fontFamilyCollection.childBegin();
        for (; it != d->fontFamilyCollection.childEnd(); it++) {
            if (!typographicFamily.fontFamily.isEmpty() && it->fontFamily == typographicFamily.fontFamily) {
                break;
            } else if (it->fontFamily == fontFamily.fontFamily) {
                break;
            }
        }
        if (it != d->fontFamilyCollection.childEnd()) {
 
            if (isWWSFamilyWithoutName) {
                wwsFamily.fontFamily = fontFamily.fontFamily;
            }
            if (!wwsFamily.fontFamily.isEmpty()) {
                // sort into wws family
                auto wws = childBegin(it);
                for (; wws != childEnd(it); wws++) {
                    if (wws->fontFamily == wwsFamily.fontFamily) {
                        break;
                    }
                }
                if (wws != childEnd(it)) {
                    d->fontFamilyCollection.insert(childEnd(wws), fontFamily);
                } else {
                    auto wwsNew = d->fontFamilyCollection.insert(childEnd(it), wwsFamily);
                    d->fontFamilyCollection.insert(childEnd(wwsNew), fontFamily);
                }
            } else if (!fontFamily.pixelSizes.isEmpty()) {
                // sort any pixel sizes into the appropriate family.
                auto pixel = childBegin(it);
                for (; pixel != childEnd(it); pixel++) {
                    if (pixel->fontFamily == fontFamily.fontFamily && pixel->fontStyle == fontFamily.fontStyle && !pixel->pixelSizes.isEmpty()) {
                        for (int pxSize = 0; pxSize < fontFamily.pixelSizes.keys().size(); pxSize++) {
                            int px = fontFamily.pixelSizes.keys().at(pxSize);
                            QStringList files = pixel->pixelSizes.value(px, QStringList());
                            files.append(fontFamily.pixelSizes.value(px));
                            pixel->pixelSizes.insert(px, files);
                        }
                        break;
                    }
                }
                if (pixel == childEnd(it)) {
                    d->fontFamilyCollection.insert(childEnd(it), fontFamily);
                }
 
            } else {
                d->fontFamilyCollection.insert(childEnd(it), fontFamily);
            }
        } else {
            auto typographic = d->fontFamilyCollection.insert(d->fontFamilyCollection.childEnd(), typographicFamily);
            if (isWWSFamilyWithoutName) {
                wwsFamily.fontFamily = fontFamily.fontFamily;
            }
            if (!wwsFamily.fontFamily.isEmpty()) {
                auto wwsNew = d->fontFamilyCollection.insert(childEnd(typographic), wwsFamily);
                d->fontFamilyCollection.insert(childEnd(wwsNew), fontFamily);
            } else {
                d->fontFamilyCollection.insert(childEnd(typographic), fontFamily);
            }
        }
    }
    return true;
}

References FontFamilyNode::axes, KoSvgText::FontFamilyAxis::axisHidden, KoSvgText::BDFFontType, FontFamilyNode::colorBitMap, FontFamilyNode::colorClrV0, FontFamilyNode::colorSVG, d, KisLibraryResourcePointer< T, P >::data(), FontFamilySizeInfo::designSize, FontFamilyNode::fileIndex, FontFamilyNode::fileName, FontFamilyNode::fontFamily, FontFamilyNode::fontStyle, FontFamilySizeInfo::high, KoSvgText::FontFamilyStyleInfo::instanceCoords, FontFamilyNode::isItalic, FontFamilyNode::isOblique, FontFamilySizeInfo::isSet, FontFamilyNode::isVariable, FontFamilyNode::lastModified, length(), FontFamilyNode::localizedFontFamilies, FontFamilyNode::localizedFontStyle, FontFamilyNode::localizedFullName, FontFamilySizeInfo::localizedLabels, FontFamilyNode::localizedTypographicStyle, FontFamilyNode::localizedWWSStyle, FontFamilySizeInfo::low, KoSvgText::FontFamilyAxis::max, KoSvgText::FontFamilyAxis::min, KoSvgText::OpenTypeFontType, OS2_OBLIQUE, OS2_REGULAR, OS2_WWS, FontFamilySizeInfo::os2table, FontFamilyNode::pixelSizes, KisLibraryResourcePointer< T, P >::reset(), FontFamilyNode::sizeInfo, FontFamilyNode::styleInfo, FontFamilySizeInfo::subFamilyID, KoSvgText::FontFamilyAxis::tag, FontFamilyNode::type, KoSvgText::Type1FontType, KoSvgText::FontFamilyAxis::value, KoSvgText::FontFamilyAxis::variableAxis, WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(), WIDTH_TAG, and KoSvgText::FontFamilyAxis::widthAxis().

addFontFromPattern()

bool KoFFWWSConverter::addFontFromPattern	(	const FcPattern *	pattern,
		FT_LibrarySP	freeTypeLibrary )

Add a font from a fontconfig pattern.

Definition at line 283 of file KoFFWWSConverter.cpp.

{
    if (!freeTypeLibrary.data()) {
        return false;
    }
 
    bool getFile = false;
    FcChar8 *fileValue{};
    if (FcPatternGetString(pattern, FC_FILE, 0, &fileValue) != FcResultMatch) {
        qWarning() << "Failed to get font file for" << pattern;
    } else {
        getFile = true;
    }
    QString filename = QString::fromUtf8(reinterpret_cast<char *>(fileValue));
 
    int indexValue{};
    if (FcPatternGetInteger(pattern, FC_INDEX, 0, &indexValue) != FcResultMatch) {
        qWarning() << "Failed to get font index for" << pattern << "(file:" << filename << ")";
        getFile = false;
    }
 
    if (getFile == false) {
        return getFile;
    }
 
    if (indexValue > 0xffff) { // this indicates the font is a variable font instance, so we don't try to load it.
        return false;
    }
 
    bool success = addFontFromFile(filename, indexValue, freeTypeLibrary);
    if (success) {
        FcLangSet *set;
        if (FcPatternGetLangSet(pattern, FC_LANG, 0, &set) != FcResultMatch) {
            qWarning() << "Failed to get font index for" << pattern << "(file:" << filename << ")";
            return success;
        }
        FcStrList *list = FcStrListCreate(FcLangSetGetLangs(set));
        FcStrListFirst(list);
        FcChar8 *langString = FcStrListNext(list);
        QString lang = QString::fromUtf8(reinterpret_cast<char *>(langString));
        QList<QLocale> languages;
        while (!lang.isEmpty()) {
            languages.append(QLocale(lang));
 
            langString = FcStrListNext(list);
            lang = QString::fromUtf8(reinterpret_cast<char *>(langString));
        }
        FcStrListDone(list);
        FcCharSet *charSet = nullptr;
        if (FcPatternGetCharSet(pattern, FC_CHARSET, 0, &charSet) != FcResultMatch) {
            return success;
        }
        addSupportedLanguagesByFile(filename, indexValue, languages, charSet);
 
    }
    return success;
}

References addFontFromFile(), addSupportedLanguagesByFile(), and KisLibraryResourcePointer< T, P >::data().

addGenericFamily()

void KoFFWWSConverter::addGenericFamily

(

const QString &

name

)

This adds a CSS generic family. Call this before sortIntoWWSFamilies.

Definition at line 847 of file KoFFWWSConverter.cpp.

{
    FontFamilyNode typographicFamily;
    FontFamilyNode fontFamily;
 
    QHash<QLocale, QString> familyNames = {{QLocale(QLocale::English), name}};
    // TODO: can and should we translate this?
    QHash<QLocale, QString> styleNames = {{QLocale(QLocale::English), "Regular"}};
 
    fontFamily.fontFamily = name;
    fontFamily.localizedFontFamilies = familyNames;
 
    fontFamily.type = KoSvgText::OpenTypeFontType;
 
    typographicFamily = fontFamily;
    fontFamily.axes.insert(WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(400));
    fontFamily.fontStyle = styleNames.values().first();
    fontFamily.localizedFontStyle = styleNames;
    QString tag = KoWritingSystemUtils::sampleTagForQLocale(QLocale(QLocale::English));
    fontFamily.sampleStrings.insert(tag, KoWritingSystemUtils::samples().key(tag));
 
    auto typographic = d->fontFamilyCollection.insert(d->fontFamilyCollection.childEnd(), typographicFamily);
    d->fontFamilyCollection.insert(childEnd(typographic), fontFamily);
}

References FontFamilyNode::axes, d, FontFamilyNode::fontFamily, FontFamilyNode::fontStyle, FontFamilyNode::localizedFontFamilies, FontFamilyNode::localizedFontStyle, KoSvgText::OpenTypeFontType, KoWritingSystemUtils::samples(), FontFamilyNode::sampleStrings, KoWritingSystemUtils::sampleTagForQLocale(), FontFamilyNode::type, WEIGHT_TAG, and KoSvgText::FontFamilyAxis::weightAxis().

addSupportedLanguagesByFile()

void KoFFWWSConverter::addSupportedLanguagesByFile	(	const QString &	filename,
		const int	index,
		const QList< QLocale > &	supportedLanguages,
		FcCharSet *	set )

Definition at line 637 of file KoFFWWSConverter.cpp.

{
    auto it = d->fontFamilyCollection.depthFirstTailBegin();
    for (; it!= d->fontFamilyCollection.depthFirstTailEnd(); it++) {
        if (it->fileName == filename && it->fileIndex == index) {
            break;
        }
    }
    if (it != d->fontFamilyCollection.depthFirstTailEnd()) {
        it->supportedLanguages = supportedLanguages;
 
        QMap<QString, QString> samples = KoWritingSystemUtils::samples();
 
        for (int i = 0; i < samples.size(); i++) {
            QString sample = samples.keys().at(i);
            bool matching = true;
            Q_FOREACH (uint unicode, sample.toUcs4()) {
                if (!FcCharSetHasChar(set, unicode)) {
                    matching = false;
                    break;
                }
            }
            if (matching) {
                it->sampleStrings.insert(samples.value(sample), sample);
            }
        }
    }
}

References d, and KoWritingSystemUtils::samples().

candidatesForCssValues()

QVector< KoFFWWSConverter::FontFileEntry > KoFFWWSConverter::candidatesForCssValues	(	const KoCSSFontInfo	info,
		quint32	xRes = 72,
		quint32	yRes = 72 ) const

candidatesForCssValues Search the nodes for the most appropriate font for the given css values. We want to give these preferential treatment to whatever fontconfig matches for us.

Returns

list of QPairs representing the filenames and file indices for the candidates.

Definition at line 1081 of file KoFFWWSConverter.cpp.

{
    QVector<FontFileEntry> candidateFileNames;
 
    int pixelSize = info.size * (qMin(xRes, yRes) / 72.0);
 
    Q_FOREACH(const QString &family, info.families) {
        auto it = d->fontFamilyCollection.compositionBegin();
        it = searchNodes(it, d->fontFamilyCollection.compositionEnd(), family);
        if (it != d->fontFamilyCollection.compositionEnd()) {
            auto wws = siblingCurrent(it);
 
            // check if we're in a typographic family by testing the hierarchy.
            // if so, select all subnodes.
            // Because we test subtree depth-first for finding the nodes, wws
            // and full names are tested before typographic.
            auto hierarchy = hierarchyBegin(wws);
            hierarchy++;
            QVector<FontFamilyNode> candidates;
            if (hierarchy == hierarchyEnd(wws)) {
                auto nodes = subtreeBegin(wws);
                auto endNodes = subtreeEnd(wws);
                for (;nodes != endNodes; nodes++) {
                    if (childBegin(nodes) == childEnd(nodes)) {
                        candidates.append(*nodes);
                    }
                }
            } else if (childBegin(wws) == childEnd(wws)) {
                candidates.append(*wws);
            } else {
                auto style = childBegin(wws);
                auto styleEnd = childEnd(wws);
                for (;style != styleEnd; style++) {
                    candidates.append(*style);
                }
            }
 
            if (candidates.size() > 1) {
                // first find width
                candidates = findNodesByAxis(candidates, WIDTH_TAG, info.width, 100.0, 100.0);
            }
 
            if (candidates.size() > 1) {
                // then find weight
                candidates = findNodesByAxis(candidates, WEIGHT_TAG, info.weight, 400.0, 500.0);
            }
            // then match italic
            if (candidates.size() > 1) {
                QVector<FontFamilyNode> italics;
                QVector<FontFamilyNode> obliques;
 
                if (wws->isVariable) {
                    qreal slantValue = info.slantMode == QFont::StyleItalic? 11: info.autoSlant? 14: info.slantValue;
                    italics = findNodesByAxis(candidates, ITALIC_TAG, 1.0, 0.0, 0.0);
                    obliques = findNodesByAxis(candidates, SLANT_TAG, -slantValue, 0.0, 0.0);
                }
                if (italics.isEmpty() && obliques.isEmpty()) {
                    Q_FOREACH(const FontFamilyNode &node, candidates) {
                        if (node.isItalic) {
                            if (!node.isOblique) {
                                italics.append(node);
                            } else {
                                obliques.append(node);
                            }
                        }
                    }
                }
 
                if (info.slantMode == QFont::StyleItalic) {
                    if (!italics.isEmpty()) {
                        candidates = italics;
                    } else if (!obliques.isEmpty()) {
                        candidates = obliques;
                    }
                } else if (info.slantMode == QFont::StyleOblique) {
                    if (!obliques.isEmpty()) {
                        candidates = obliques;
                    } else if (!italics.isEmpty()) {
                        candidates = italics;
                    }
                } else {
                    QStringList slantedFontFiles;
                    QVector<FontFamilyNode> regular;
                    Q_FOREACH(const FontFamilyNode &italic, italics) {
                        slantedFontFiles.append(italic.fileName);
                    }
                    Q_FOREACH(const FontFamilyNode &oblique, obliques) {
                        slantedFontFiles.append(oblique.fileName);
                    }
                    Q_FOREACH(const FontFamilyNode &node, candidates) {
                        if (!slantedFontFiles.contains(node.fileName)) {
                            regular.append(node);
                        }
                    }
                    if (!regular.isEmpty()) {
                        candidates = regular;
                    }
                }
            }
 
            // prefer opentype
            if (candidates.size() > 1) {
                QVector<FontFamilyNode> openType;
                Q_FOREACH(const FontFamilyNode &node, candidates) {
                    if (node.type == KoSvgText::OpenTypeFontType) {
                        openType.append(node);
                    }
                }
                if (!openType.isEmpty()) {
                    candidates = openType;
                }
            }
 
            // finally, match size.
            Q_FOREACH(const FontFamilyNode &node, candidates) {
                QStringList fileNames = node.otherFiles;
                fileNames.append(node.fileName);
                fileNames = node.pixelSizes.value(pixelSize, fileNames);
                Q_FOREACH(const QString &fileName, fileNames) {
                    if (fileName.isEmpty()) continue;
                    FontFileEntry entry;
                    entry.fileName = fileName;
                    entry.fontIndex = node.fileIndex;
                    candidateFileNames.append(entry);
                }
            }
        }
    }
    return candidateFileNames;
}

References KoCSSFontInfo::autoSlant, d, KoCSSFontInfo::families, FontFamilyNode::fileIndex, FontFamilyNode::fileName, KoFFWWSConverter::FontFileEntry::fileName, findNodesByAxis(), KoFFWWSConverter::FontFileEntry::fontIndex, FontFamilyNode::isItalic, FontFamilyNode::isOblique, ITALIC_TAG, KoSvgText::OpenTypeFontType, FontFamilyNode::otherFiles, FontFamilyNode::pixelSizes, searchNodes(), KoCSSFontInfo::size, SLANT_TAG, KoCSSFontInfo::slantMode, KoCSSFontInfo::slantValue, FontFamilyNode::type, KoCSSFontInfo::weight, WEIGHT_TAG, KoCSSFontInfo::width, and WIDTH_TAG.

collectFamilies()

QList< KoFontFamilyWWSRepresentation > KoFFWWSConverter::collectFamilies

(

)

const

Collects all WWSFamilies (that is, CSS compatible groupings of font files) and return them.

Definition at line 945 of file KoFFWWSConverter.cpp.

{
    QList<KoFontFamilyWWSRepresentation> collection;
    for (auto typographic = d->fontFamilyCollection.childBegin(); typographic != d->fontFamilyCollection.childEnd(); typographic++) {
        auto counter = childBegin(typographic);
        counter++;
        bool singleFamily = childBegin(typographic) != childEnd(typographic) && std::next(childBegin(typographic)) == childEnd(typographic);
 
        for (auto wws = childBegin(typographic); wws != childEnd(typographic); wws++) {
 
            collection.append(createRepresentation(wws, typographic, singleFamily));
        }
    }
    return collection;
}

References createRepresentation(), and d.

debugInfo()

void KoFFWWSConverter::debugInfo

(

)

const

Print out the font family hierarchy into the debug output.

Definition at line 1213 of file KoFFWWSConverter.cpp.

{
    qDebug() << "Debug for font family collection" << KisForestDetail::size(d->fontFamilyCollection);
    QString spaces;
    for (auto it = compositionBegin(d->fontFamilyCollection); it != compositionEnd(d->fontFamilyCollection); it++) {
        if (it.state() == KisForestDetail::Enter) {
            QStringList debugInfo = it->debugInfo();
            for (int i = 0; i< debugInfo.size(); i++) {
                if (i==0) {
                    qDebug().noquote() << QString(spaces + "+") << debugInfo.at(i);
                } else {
                    qDebug().noquote() << QString(spaces + "| ") << debugInfo.at(i);
                }
            }
            spaces.append("    ");
        }
 
        if (it.state() == KisForestDetail::Leave) {
            spaces.chop(4);
        }
    }
}

References d, debugInfo(), KisForestDetail::Enter, KisForestDetail::Leave, and KisForestDetail::size().

representationByFamilyName()

std::optional< KoFontFamilyWWSRepresentation > KoFFWWSConverter::representationByFamilyName

(

const QString &

familyName

)

const

Gets a single WWSFamily representation for a given CSS Family Name, used by KoFontStorage.

Definition at line 998 of file KoFFWWSConverter.cpp.

{
    for (auto typographic = d->fontFamilyCollection.childBegin(); typographic != d->fontFamilyCollection.childEnd(); typographic++) {
        auto counter = childBegin(typographic);
        counter++;
        bool singleFamily = counter == childEnd(typographic);
 
        for (auto wws = childBegin(typographic); wws != childEnd(typographic); wws++) {
            if (wws->fontFamily == familyName) {
                return std::make_optional(createRepresentation(wws, typographic, singleFamily));
            }
        }
    }
    return std::nullopt;
}

References createRepresentation(), and d.

sortIntoWWSFamilies()

void KoFFWWSConverter::sortIntoWWSFamilies

(

)

Sort any straggling fonts into WWSFamilies.

Definition at line 666 of file KoFFWWSConverter.cpp.

{
    QStringList wwsNames;
    // Some font families have predefined wws families, others don't. This function sorts out everything so that each font file has
    // a wws family in between the typographic and font-file nodes, this is important, because the wws family will be the one presented
    // as the font-family resource.
    for (auto typographic = d->fontFamilyCollection.childBegin(); typographic != d->fontFamilyCollection.childEnd(); typographic++) {
        KisForest<FontFamilyNode> tempList;
 
        QVector<qreal> weights;
        QVector<qreal> widths;
        QVector<int> fileIndices;
        QVector<KoSvgText::FontFormatType> types;
 
        // This takes all of the current children that aren't inside a wws-node already and puts them into a temp list,
        // as well as tallying the current widths and weights. We need these to find the most regular value.
        QVector<KisForest<FontFamilyNode>::child_iterator> deleteList;
        for (auto child = childBegin(typographic); child != childEnd(typographic); child++) {
            if (childBegin(child) != childEnd(child)) {
                wwsNames.append(child->fontFamily);
                continue;
            }
            tempList.insert(tempList.childEnd(), *child);
            qreal wght = child->axes.value(WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(400)).value;
            if (!weights.contains(wght)) weights.append(wght);
            qreal wdth = child->axes.value(WIDTH_TAG, KoSvgText::FontFamilyAxis::widthAxis(100)).value;
            if (!widths.contains(wdth)) widths.append(wdth);
            if (!fileIndices.contains(child->fileIndex)) fileIndices.append(child->fileIndex);
            types.append(child->type);
            deleteList.append(child);
        }
        while (!deleteList.isEmpty()) {
            auto child = deleteList.takeFirst();
            KIS_ASSERT_RECOVER_NOOP(childBegin(child) == childEnd(child));
            d->fontFamilyCollection.erase(child);
        }
        if (KisForestDetail::size(tempList) > 0) {
            //Do most regular first...
            KoSvgText::FontFormatType testType = types.contains(KoSvgText::OpenTypeFontType)? KoSvgText::OpenTypeFontType: types.first();
            QVector<QPair<QString, QString>> existing;
            for (auto font = tempList.childBegin(); font != tempList.childEnd(); font++) {
                const qreal testWeight = weights.contains(400)? 400: weights.first();
                const qreal testWidth = widths.contains(100)? 100: widths.first();
                // We want to select the first file index if possible.
                const int testFileIndex = fileIndices.contains(0)? 0: fileIndices.first();
 
                bool widthTested = !font->axes.keys().contains(WIDTH_TAG);
                widthTested = widthTested? true: qFuzzyCompare(font->axes.value(WIDTH_TAG).value, testWidth);
 
                QPair<QString, QString> fontStyle(font->fontFamily, font->fontStyle);
                if (qFuzzyCompare(font->axes.value(WEIGHT_TAG).value, testWeight) && widthTested
                        && !font->isItalic
                        && !font->isOblique
                        && ( ( fileIndices.size() > 1 && font->fileIndex == testFileIndex ) || ( fileIndices.size()<=1 ))
                        && font->type == testType
                        && !existing.contains(fontStyle)) {
                    FontFamilyNode wwsFamily = FontFamilyNode::createWWSFamilyNode(*font, *typographic, wwsNames);
                    wwsNames.append(wwsFamily.fontFamily);
                    existing.append(fontStyle);
 
                    auto newWWS = d->fontFamilyCollection.insert(childEnd(typographic), wwsFamily);
                    d->fontFamilyCollection.insert(childEnd(newWWS), *font);
                    deleteList.append(font);
                }
            }
            while (!deleteList.isEmpty()) {
                auto child = deleteList.takeFirst();
                KIS_ASSERT_RECOVER_NOOP(childBegin(child) == childEnd(child));
                tempList.erase(child);
            }
            // Then sort the rest of the family nodes into wws families.
            for (auto font = tempList.childBegin(); font != tempList.childEnd(); font++) {
                auto wws = childBegin(typographic);
                auto wwsCandidate = childEnd(typographic);
                for (; wws != childEnd(typographic); wws++) {
                    auto wwsChild = childBegin(wws);
                    if (font->type != KoSvgText::OpenTypeFontType && font->type != KoSvgText::Type1FontType) {
                        // Hack for really old fonts.
                        // It's questionable whether this is wise, given that it is not the family name,
                        // but it seems CSS is explicitly vague about what the family name is, because
                        // of the varying ways a font can be assigned a family name.
                        // Like, it is technically correct, because it allows us to select fonts with CSS
                        // that would otherwise be unselectable, but this does mean that other applications
                        // would need to have our exact idea of a CSS family name.
                        if (wws->fontStyle.toLower() != "regular"
                                && !font->fontStyle.contains(wws->fontStyle)) {
                            continue;
                        }
                    }
                    // In a previous version of the code, variable and non-variable were not mixed, but after reconsidering,
                    // they probably should be sorted together. The code will prioritize variable fonts in any case.
 
                    if (!wwsChild->sizeInfo.compare(font->sizeInfo)) {
                        // Skip sorting if the WWS family has size info that is incompatible with the sorted font.
                        continue;
                    }
                    for (; wwsChild != childEnd(wws); wwsChild++) {
                        if (wwsChild->isItalic == font->isItalic
                                && wwsChild->isOblique == font->isOblique
                                && wwsChild->compareAxes(font->axes)
                                && wwsChild->hasAnyColor() == font->hasAnyColor()) {
                            break;
                        }
                    }
                    if (wwsChild != childEnd(wws)) {
                        if (wwsChild->fontFamily == font->fontFamily && wwsChild->fontStyle == font->fontStyle) {
                            // If, for all intends and purposes, the font seems to be the same, merge nodes.
                            // This sometimes happens with installations where the same font is installed in
                            // a variety of formats. We want to prefer the opentype version in any case.
                            if (wwsChild->type != KoSvgText::OpenTypeFontType && font->type == KoSvgText::OpenTypeFontType) {
                                wwsChild->otherFiles.append(wwsChild->fileName);
                                wwsChild->otherFiles.append(font->otherFiles);
                                wwsChild->fileName = font->fileName;
                                wwsChild->type = KoSvgText::OpenTypeFontType;
                            } else {
                                wwsChild->otherFiles.append(font->fileName);
                                wwsChild->otherFiles.append(font->otherFiles);
                            }
                            if (wwsChild->lastModified < font->lastModified) {
                                wwsChild->lastModified = font->lastModified;
                            }
                            break;
                        } else {
                            continue;
                        }
                    } else {
                        /*
                         * Try to match the wws family with the same fontfamily, otherwise select the first candidate.
                         */
                        if (wwsCandidate == childEnd(typographic)) {
                            wwsCandidate = wws;
                        }
                        if (wws->fontFamily == font->fontFamily) {
                            wwsCandidate = wws;
                            break;
                        }
                    }
                }
                if (wwsCandidate != childEnd(typographic)) {
                    d->fontFamilyCollection.insert(childEnd(wwsCandidate), *font);
                } else if (wws == childEnd(typographic)) {
                    FontFamilyNode wwsFamily = FontFamilyNode::createWWSFamilyNode(*font, *typographic, wwsNames);
                    wwsNames.append(wwsFamily.fontFamily);
                    auto newWWS = d->fontFamilyCollection.insert(childEnd(typographic), wwsFamily);
                    if (wwsFamily.fontFamily != typographic->fontFamily) {
                        font->localizedTypographicStyle.clear();
                    }
                    d->fontFamilyCollection.insert(childEnd(newWWS), *font);
                }
            }
            // This only triggers when the first wws family was created with the typographic name,
            // yet more wws families have followed after sorting was finished, and this name might be not the most precise.
            if (wwsNames.contains(typographic->fontFamily)  && std::distance(childBegin(typographic), childEnd(typographic)) > 1) {
                for (auto wws = childBegin(typographic); wws != childEnd(typographic); wws++) {
                    if (wws->fontFamily == typographic->fontFamily) {
                        if (wwsNames.contains(childBegin(wws)->fontFamily)) {
                            const QString otherWWSName = childBegin(wws)->fontFamily;
                            // Also rename any other wwsfamilies that has been using the second style.
                            for (auto otherwws = childBegin(typographic); otherwws != childEnd(typographic); otherwws++) {
                                if (otherwws->fontFamily == otherWWSName) {
                                    otherwws->fontFamily = childBegin(otherwws)->fontFamily + " " + childBegin(otherwws)->fontStyle;
                                    QHash<QLocale, QString> families;
                                    const QHash<QLocale, QString> styles = childBegin(otherwws)->localizedFontStyle;
                                    Q_FOREACH (const QLocale l, otherwws->localizedFontFamilies.keys()) {
                                        families.insert(l, otherwws->localizedFontFamilies.value(l)+" "+styles.value(l, childBegin(otherwws)->fontStyle));
                                    }
                                    otherwws->localizedFontFamilies = families;
                                    break;
                                }
                            }
                        }
                        wws->fontFamily = childBegin(wws)->fontFamily;
                        childBegin(wws)->localizedTypographicStyle.clear();
                        break;
                    }
                }
            }
        }
    }
}

References KisForestDetail::Forest< T >::childBegin(), KisForestDetail::Forest< T >::childEnd(), FontFamilyNode::createWWSFamilyNode(), d, KisForestDetail::Forest< T >::erase(), FontFamilyNode::fontFamily, KisForestDetail::Forest< T >::insert(), KIS_ASSERT_RECOVER_NOOP, KoSvgText::OpenTypeFontType, qFuzzyCompare(), KisForestDetail::size(), KoSvgText::Type1FontType, value(), WEIGHT_TAG, KoSvgText::FontFamilyAxis::weightAxis(), WIDTH_TAG, and KoSvgText::FontFamilyAxis::widthAxis().

wwsNameByFamilyName()

std::optional< QString > KoFFWWSConverter::wwsNameByFamilyName

(

const QString

familyName

)

const

Used to find the closest corresponding resource when the family name doesn't match.

Definition at line 1014 of file KoFFWWSConverter.cpp.

{
    auto it = d->fontFamilyCollection.compositionBegin();
    it = searchNodes(it, d->fontFamilyCollection.compositionEnd(), familyName);
    if (it != d->fontFamilyCollection.compositionEnd()) {
 
        bool isChild = childBegin(it) == childEnd(it);
        auto wws = siblingCurrent(it);
 
        // check if we're in a typographic family by testing the hierarchy.
        // if so, select the wws family.
        auto hierarchy = hierarchyBegin(wws);
        hierarchy++;
        if (isChild) {
            wws = siblingCurrent(hierarchy);
        } else if (hierarchy == hierarchyEnd(wws)) {
            wws = childBegin(it);
        }
        return std::make_optional(wws->fontFamily);
    }
    return std::nullopt;
}

References d, and searchNodes().

Member Data Documentation

d

QScopedPointer<Private> KoFFWWSConverter::d

private

Definition at line 108 of file KoFFWWSConverter.h.

---

The documentation for this class was generated from the following files:

• libs/flake/text/KoFFWWSConverter.h
• libs/flake/text/KoFFWWSConverter.cpp