vcl: Drop the PrintFont -> FastPrintFontInfo -> FontAttributes indirection

We want FontAttributes at the end, so lets have them up front instead of
the intermediary structures.

Change-Id: Iafdf17f4a7615f0c3d972e6080cebea0183840b7
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/155191
Tested-by: Jenkins
Reviewed-by: خالد حسني <khaled@libreoffice.org>
diff --git a/vcl/inc/unx/fontmanager.hxx b/vcl/inc/unx/fontmanager.hxx
index 8010c17..a81975f 100644
--- a/vcl/inc/unx/fontmanager.hxx
+++ b/vcl/inc/unx/fontmanager.hxx
@@ -59,31 +59,6 @@ class PPDParser;

typedef int fontID;

struct FastPrintFontInfo
{
    fontID                         m_nID; // FontID

    // font attributes
    OUString                       m_aFamilyName;
    OUString                       m_aStyleName;
    FontFamily                     m_eFamilyStyle;
    FontItalic                     m_eItalic;
    FontWidth                      m_eWidth;
    FontWeight                     m_eWeight;
    FontPitch                      m_ePitch;
    rtl_TextEncoding               m_aEncoding;

    FastPrintFontInfo()
        : m_nID(0)
        , m_eFamilyStyle(FAMILY_DONTKNOW)
        , m_eItalic(ITALIC_DONTKNOW)
        , m_eWidth(WIDTH_DONTKNOW)
        , m_eWeight(WEIGHT_DONTKNOW)
        , m_ePitch(PITCH_DONTKNOW)
        , m_aEncoding(RTL_TEXTENCODING_DONTKNOW)
    {}
};

// a class to manage printable fonts

class VCL_PLUGIN_PUBLIC PrintFontManager
@@ -93,15 +68,7 @@ class VCL_PLUGIN_PUBLIC PrintFontManager

    struct VCL_DLLPRIVATE PrintFont
    {
        // font attributes
        OUString          m_aFamilyName;
        OUString          m_aStyleName;
        FontFamily        m_eFamilyStyle;
        FontItalic        m_eItalic;
        FontWidth         m_eWidth;
        FontWeight        m_eWeight;
        FontPitch         m_ePitch;
        rtl_TextEncoding  m_aEncoding;
        FontAttributes    m_aFontAttributes;

        int               m_nDirectory;       // atom containing system dependent path
        OString           m_aFontFile;        // relative to directory
@@ -137,13 +104,6 @@ class VCL_PLUGIN_PUBLIC PrintFontManager

    static FontFamily matchFamilyName( std::u16string_view rFamily );

    const PrintFont* getFont( fontID nID ) const
    {
        auto it = m_aFonts.find( nID );
        return it == m_aFonts.end() ? nullptr : &it->second;
    }
    static void fillPrintFontInfo(const PrintFont& rFont, FastPrintFontInfo& rInfo);

    OString getDirectory( int nAtom ) const;
    int getDirectoryAtom( const OString& rDirectory );

@@ -184,12 +144,15 @@ public:

    void initialize();

    const PrintFont* getFont( fontID nID ) const
    {
        auto it = m_aFonts.find( nID );
        return it == m_aFonts.end() ? nullptr : &it->second;
    }

    // returns the ids of all managed fonts.
    void getFontList( std::vector< fontID >& rFontIDs );

    // get fast font info for a specific font
    bool getFontFastInfo( fontID nFontID, FastPrintFontInfo& rInfo ) const;

    // routines to get font info in small pieces

    // get a specific fonts system dependent filename
@@ -211,16 +174,15 @@ public:
    <p>
    <code>matchFont</code> matches a pattern of font characteristics
    and returns the closest match if possible. If a match was found
    the <code>FastPrintFontInfo</code> passed in as parameter
    will be update to the found matching font.
    it will update rDFA to the found matching font.
    </p>
    <p>
    implementation note: currently the function is only implemented
    for fontconfig.
    </p>

    @param rInfo
    out of the FastPrintFontInfo structure the following
    @param rDFA
    out of the FontAttributes structure the following
    fields will be used for the match:
    <ul>
    <li>family name</li>
@@ -235,7 +197,7 @@ public:
    locale will be used for font matching also; e.g. "Sans" can result
    in different fonts in e.g. english and japanese
     */
    void matchFont( FastPrintFontInfo& rInfo, const css::lang::Locale& rLocale );
    bool matchFont(FontAttributes& rDFA, const css::lang::Locale& rLocale);

    static std::unique_ptr<FontConfigFontOptions> getFontOptions(const FontAttributes& rFontAttributes, int nSize);

diff --git a/vcl/inc/unx/genpspgraphics.h b/vcl/inc/unx/genpspgraphics.h
index 81734cd..2a9c6ae 100644
--- a/vcl/inc/unx/genpspgraphics.h
+++ b/vcl/inc/unx/genpspgraphics.h
@@ -24,7 +24,6 @@
#include <vcl/vclenum.hxx>
#include <config_cairo_canvas.h>

#include <unx/fontmanager.hxx>
#include <salgdi.hxx>
#include <sallayout.hxx>

@@ -61,9 +60,6 @@ public:

    void                    Init(psp::JobData* pJob);

    // helper methods
    static FontAttributes   Info2FontAttributes(const psp::FastPrintFontInfo&);

    // override all pure virtual methods
    virtual SalGraphicsImpl* GetImpl() const override
    {
diff --git a/vcl/qt5/QtFrame.cxx b/vcl/qt5/QtFrame.cxx
index 5c99479..179d436 100644
--- a/vcl/qt5/QtFrame.cxx
+++ b/vcl/qt5/QtFrame.cxx
@@ -1028,37 +1028,32 @@ static Color toColor(const QColor& rColor)

static bool toVclFont(const QFont& rQFont, const css::lang::Locale& rLocale, vcl::Font& rVclFont)
{
    psp::FastPrintFontInfo aInfo;
    QFontInfo qFontInfo(rQFont);
    FontAttributes aFA;
    QtFontFace::fillAttributesFromQFont(rQFont, aFA);

    OUString sFamilyName = toOUString(rQFont.family());
    aInfo.m_aFamilyName = sFamilyName;
    aInfo.m_eItalic = QtFontFace::toFontItalic(qFontInfo.style());
    aInfo.m_eWeight = QtFontFace::toFontWeight(qFontInfo.weight());
    aInfo.m_eWidth = QtFontFace::toFontWidth(rQFont.stretch());

    psp::PrintFontManager::get().matchFont(aInfo, rLocale);
    bool bFound = psp::PrintFontManager::get().matchFont(aFA, rLocale);
    SAL_INFO("vcl.qt", "font match result for '"
                           << sFamilyName << "': "
                           << (aInfo.m_nID != 0 ? OUString::Concat("'") + aInfo.m_aFamilyName + "'"
                                                : OUString("failed")));
                           << rQFont.family() << "': "
                           << (bFound ? OUString::Concat("'") + aFA.GetFamilyName() + "'"
                                      : OUString("failed")));

    if (aInfo.m_nID == 0)
    if (!bFound)
        return false;

    QFontInfo qFontInfo(rQFont);
    int nPointHeight = qFontInfo.pointSize();
    if (nPointHeight <= 0)
        nPointHeight = rQFont.pointSize();

    vcl::Font aFont(aInfo.m_aFamilyName, Size(0, nPointHeight));
    if (aInfo.m_eWeight != WEIGHT_DONTKNOW)
        aFont.SetWeight(aInfo.m_eWeight);
    if (aInfo.m_eWidth != WIDTH_DONTKNOW)
        aFont.SetWidthType(aInfo.m_eWidth);
    if (aInfo.m_eItalic != ITALIC_DONTKNOW)
        aFont.SetItalic(aInfo.m_eItalic);
    if (aInfo.m_ePitch != PITCH_DONTKNOW)
        aFont.SetPitch(aInfo.m_ePitch);
    vcl::Font aFont(aFA.GetFamilyName(), Size(0, nPointHeight));
    if (aFA.GetWeight() != WEIGHT_DONTKNOW)
        aFont.SetWeight(aFA.GetWeight());
    if (aFA.GetWidthType() != WIDTH_DONTKNOW)
        aFont.SetWidthType(aFA.GetWidthType());
    if (aFA.GetItalic() != ITALIC_DONTKNOW)
        aFont.SetItalic(aFA.GetItalic());
    if (aFA.GetPitch() != PITCH_DONTKNOW)
        aFont.SetPitch(aFA.GetPitch());

    rVclFont = aFont;
    return true;
diff --git a/vcl/qt5/QtGraphics_Text.cxx b/vcl/qt5/QtGraphics_Text.cxx
index f189a04..c7486da 100644
--- a/vcl/qt5/QtGraphics_Text.cxx
+++ b/vcl/qt5/QtGraphics_Text.cxx
@@ -28,7 +28,6 @@
#include <unx/geninst.h>
#include <unx/fontmanager.hxx>
#include <unx/glyphcache.hxx>
#include <unx/genpspgraphics.h>

#include <sallayout.hxx>
#include <font/PhysicalFontCollection.hxx>
@@ -94,23 +93,23 @@ void QtGraphics::GetDevFontList(vcl::font::PhysicalFontCollection* pPFC)
    FreetypeManager& rFontManager = FreetypeManager::get();
    psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
    ::std::vector<psp::fontID> aList;
    psp::FastPrintFontInfo aInfo;

    rMgr.getFontList(aList);
    for (auto const& elem : aList)
    for (auto const& nFontId : aList)
    {
        if (!rMgr.getFontFastInfo(elem, aInfo))
        auto const* pFont = rMgr.getFont(nFontId);
        if (!pFont)
            continue;

        // normalize face number to the FreetypeManager
        int nFaceNum = rMgr.getFontFaceNumber(aInfo.m_nID);
        int nVariantNum = rMgr.getFontFaceVariation(aInfo.m_nID);
        int nFaceNum = rMgr.getFontFaceNumber(nFontId);
        int nVariantNum = rMgr.getFontFaceVariation(nFontId);

        // inform FreetypeManager about this font provided by the PsPrint subsystem
        FontAttributes aDFA = GenPspGraphics::Info2FontAttributes(aInfo);
        aDFA.IncreaseQualityBy(4096);
        const OString& rFileName = rMgr.getFontFileSysPath(aInfo.m_nID);
        rFontManager.AddFontFile(rFileName, nFaceNum, nVariantNum, aInfo.m_nID, aDFA);
        FontAttributes aFA = pFont->m_aFontAttributes;
        aFA.IncreaseQualityBy(4096);
        const OString& rFileName = rMgr.getFontFileSysPath(nFontId);
        rFontManager.AddFontFile(rFileName, nFaceNum, nVariantNum, nFontId, aFA);
    }

    if (bUseFontconfig)
diff --git a/vcl/unx/generic/fontmanager/fontconfig.cxx b/vcl/unx/generic/fontmanager/fontconfig.cxx
index 57af594..ad9bf6c2 100644
--- a/vcl/unx/generic/fontmanager/fontconfig.cxx
+++ b/vcl/unx/generic/fontmanager/fontconfig.cxx
@@ -706,17 +706,18 @@ void PrintFontManager::countFontconfigFonts()

            if (xUpdate)
            {
                auto& rDFA = xUpdate->m_aFontAttributes;
                // set family name
                if( eWeightRes == FcResultMatch )
                    xUpdate->m_eWeight = convertWeight(weight);
                    rDFA.SetWeight(convertWeight(weight));
                if( eWidthRes == FcResultMatch )
                    xUpdate->m_eWidth = convertWidth(width);
                    rDFA.SetWidthType(convertWidth(width));
                if( eSpacRes == FcResultMatch )
                    xUpdate->m_ePitch = convertSpacing(spacing);
                    rDFA.SetPitch(convertSpacing(spacing));
                if( eSlantRes == FcResultMatch )
                    xUpdate->m_eItalic = convertSlant(slant);
                    rDFA.SetItalic(convertSlant(slant));
                if( eStyleRes == FcResultMatch )
                    xUpdate->m_aStyleName = OStringToOUString( std::string_view( reinterpret_cast<char*>(style) ), RTL_TEXTENCODING_UTF8 );
                    rDFA.SetStyleName(OStringToOUString( std::string_view( reinterpret_cast<char*>(style) ), RTL_TEXTENCODING_UTF8 ));
                if( eIndexRes == FcResultMatch )
                    xUpdate->m_nVariationEntry = GetVariationIndex(nEntryId);

@@ -1076,12 +1077,12 @@ void PrintFontManager::Substitute(vcl::font::FontSelectPattern &rPattern, OUStri
                OString aDir, aBase, aOrgPath( reinterpret_cast<char*>(file) );
                splitPath( aOrgPath, aDir, aBase );
                int nDirID = getDirectoryAtom( aDir );
                fontID aFont = findFontFileID(nDirID, aBase, GetCollectionIndex(nEntryId), GetVariationIndex(nEntryId));
                if( aFont > 0 )
                fontID nFontID = findFontFileID(nDirID, aBase, GetCollectionIndex(nEntryId), GetVariationIndex(nEntryId));
                auto const* pFont = getFont(nFontID);
                if (pFont)
                {
                    FastPrintFontInfo aInfo;
                    bRet = getFontFastInfo( aFont, aInfo );
                    rPattern.maSearchName = aInfo.m_aFamilyName;
                    rPattern.maSearchName = pFont->m_aFontAttributes.GetFamilyName();
                    bRet = true;
                }
            }

@@ -1269,8 +1270,9 @@ std::unique_ptr<FontConfigFontOptions> PrintFontManager::getFontOptions(const Fo
}


void PrintFontManager::matchFont( FastPrintFontInfo& rInfo, const css::lang::Locale& rLocale )
bool PrintFontManager::matchFont(FontAttributes& rDFA, const css::lang::Locale& rLocale)
{
    bool bFound = false;
    FontCfgWrapper& rWrapper = FontCfgWrapper::get();

    FcConfig* pConfig = FcConfigGetCurrent();
@@ -1282,11 +1284,11 @@ void PrintFontManager::matchFont( FastPrintFontInfo& rInfo, const css::lang::Loc
    if (!aLangAttrib.isEmpty())
        FcPatternAddString(pPattern, FC_LANG, reinterpret_cast<FcChar8 const *>(aLangAttrib.getStr()));

    OString aFamily = OUStringToOString( rInfo.m_aFamilyName, RTL_TEXTENCODING_UTF8 );
    OString aFamily = OUStringToOString(rDFA.GetFamilyName(), RTL_TEXTENCODING_UTF8);
    if( !aFamily.isEmpty() )
        FcPatternAddString(pPattern, FC_FAMILY, reinterpret_cast<FcChar8 const *>(aFamily.getStr()));

    addtopattern(pPattern, rInfo.m_eItalic, rInfo.m_eWeight, rInfo.m_eWidth, rInfo.m_ePitch);
    addtopattern(pPattern, rDFA.GetItalic(), rDFA.GetWeight(), rDFA.GetWidthType(), rDFA.GetPitch());

    FcConfigSubstitute(pConfig, pPattern, FcMatchPattern);
    FcDefaultSubstitute(pPattern);
@@ -1311,11 +1313,15 @@ void PrintFontManager::matchFont( FastPrintFontInfo& rInfo, const css::lang::Loc
                OString aDir, aBase, aOrgPath( reinterpret_cast<char*>(file) );
                splitPath( aOrgPath, aDir, aBase );
                int nDirID = getDirectoryAtom( aDir );
                fontID aFont = findFontFileID(nDirID, aBase,
                fontID nFontID = findFontFileID(nDirID, aBase,
                                              GetCollectionIndex(nEntryId),
                                              GetVariationIndex(nEntryId));
                if( aFont > 0 )
                    getFontFastInfo( aFont, rInfo );
                auto const* pFont = getFont(nFontID);
                if (pFont)
                {
                    rDFA = pFont->m_aFontAttributes;
                    bFound = true;
                }
            }
        }
        // info: destroying the pSet destroys pResult implicitly
@@ -1325,6 +1331,8 @@ void PrintFontManager::matchFont( FastPrintFontInfo& rInfo, const css::lang::Loc

    // cleanup
    FcPatternDestroy( pPattern );

    return bFound;
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/unx/generic/fontmanager/fontmanager.cxx b/vcl/unx/generic/fontmanager/fontmanager.cxx
index 2a6333f..a3d77c6 100644
--- a/vcl/unx/generic/fontmanager/fontmanager.cxx
+++ b/vcl/unx/generic/fontmanager/fontmanager.cxx
@@ -81,13 +81,7 @@ static sal_uInt16 getUInt16BE( const sal_uInt8*& pBuffer )
 *  PrintFont implementations
 */
PrintFontManager::PrintFont::PrintFont()
:   m_eFamilyStyle(FAMILY_DONTKNOW)
,   m_eItalic(ITALIC_DONTKNOW)
,   m_eWidth(WIDTH_DONTKNOW)
,   m_eWeight(WEIGHT_DONTKNOW)
,   m_ePitch(PITCH_DONTKNOW)
,   m_aEncoding(RTL_TEXTENCODING_DONTKNOW)
,   m_nDirectory(0)
:   m_nDirectory(0)
,   m_nCollectionEntry(0)
,   m_nVariationEntry(0)
{
@@ -514,20 +508,23 @@ bool PrintFontManager::analyzeSfntFile( PrintFont& rFont ) const
    OString aFile = getFontFile( rFont );
    TrueTypeFont* pTTFont = nullptr;

    auto& rDFA = rFont.m_aFontAttributes;
    rDFA.SetQuality(512);

    auto const e = OpenTTFontFile( aFile.getStr(), rFont.m_nCollectionEntry, &pTTFont );
    if( e == SFErrCodes::Ok )
    {
        TTGlobalFontInfo aInfo;
        GetTTGlobalFontInfo( pTTFont, & aInfo );

        if (rFont.m_aFamilyName.isEmpty())
        if (rDFA.GetFamilyName().isEmpty())
        {
            ::std::vector< OUString > aNames;
            analyzeSfntFamilyName( pTTFont, aNames );

            if( !aNames.empty() )
            {
                rFont.m_aFamilyName = aNames.front();
                rDFA.SetFamilyName(aNames.front());
                aNames.erase(aNames.begin());
            }
            else
@@ -540,53 +537,53 @@ bool PrintFontManager::analyzeSfntFile( PrintFont& rFont ) const
                 if ( dotIndex == -1 )
                     dotIndex = rFont.m_aFontFile.getLength();

                 rFont.m_aFamilyName = OStringToOUString(rFont.m_aFontFile.subView(0, dotIndex), aEncoding);
                 rDFA.SetFamilyName(OStringToOUString(rFont.m_aFontFile.subView(0, dotIndex), aEncoding));
            }
        }

        if( !aInfo.usubfamily.isEmpty() )
            rFont.m_aStyleName = aInfo.usubfamily;
            rDFA.SetStyleName(aInfo.usubfamily);

        rFont.m_eFamilyStyle = matchFamilyName(rFont.m_aFamilyName);
        rDFA.SetFamilyType(matchFamilyName(rDFA.GetFamilyName()));

        switch( aInfo.weight )
        {
            case FW_THIN:           rFont.m_eWeight = WEIGHT_THIN; break;
            case FW_EXTRALIGHT: rFont.m_eWeight = WEIGHT_ULTRALIGHT; break;
            case FW_LIGHT:          rFont.m_eWeight = WEIGHT_LIGHT; break;
            case FW_MEDIUM:     rFont.m_eWeight = WEIGHT_MEDIUM; break;
            case FW_SEMIBOLD:       rFont.m_eWeight = WEIGHT_SEMIBOLD; break;
            case FW_BOLD:           rFont.m_eWeight = WEIGHT_BOLD; break;
            case FW_EXTRABOLD:      rFont.m_eWeight = WEIGHT_ULTRABOLD; break;
            case FW_BLACK:          rFont.m_eWeight = WEIGHT_BLACK; break;
            case FW_THIN:       rDFA.SetWeight(WEIGHT_THIN); break;
            case FW_EXTRALIGHT: rDFA.SetWeight(WEIGHT_ULTRALIGHT); break;
            case FW_LIGHT:      rDFA.SetWeight(WEIGHT_LIGHT); break;
            case FW_MEDIUM:     rDFA.SetWeight(WEIGHT_MEDIUM); break;
            case FW_SEMIBOLD:   rDFA.SetWeight(WEIGHT_SEMIBOLD); break;
            case FW_BOLD:       rDFA.SetWeight(WEIGHT_BOLD); break;
            case FW_EXTRABOLD:  rDFA.SetWeight(WEIGHT_ULTRABOLD); break;
            case FW_BLACK:      rDFA.SetWeight(WEIGHT_BLACK); break;

            case FW_NORMAL:
            default:        rFont.m_eWeight = WEIGHT_NORMAL; break;
            default:            rDFA.SetWeight(WEIGHT_NORMAL); break;
        }

        switch( aInfo.width )
        {
            case FWIDTH_ULTRA_CONDENSED:    rFont.m_eWidth = WIDTH_ULTRA_CONDENSED; break;
            case FWIDTH_EXTRA_CONDENSED:    rFont.m_eWidth = WIDTH_EXTRA_CONDENSED; break;
            case FWIDTH_CONDENSED:          rFont.m_eWidth = WIDTH_CONDENSED; break;
            case FWIDTH_SEMI_CONDENSED: rFont.m_eWidth = WIDTH_SEMI_CONDENSED; break;
            case FWIDTH_SEMI_EXPANDED:      rFont.m_eWidth = WIDTH_SEMI_EXPANDED; break;
            case FWIDTH_EXPANDED:           rFont.m_eWidth = WIDTH_EXPANDED; break;
            case FWIDTH_EXTRA_EXPANDED: rFont.m_eWidth = WIDTH_EXTRA_EXPANDED; break;
            case FWIDTH_ULTRA_EXPANDED: rFont.m_eWidth = WIDTH_ULTRA_EXPANDED; break;
            case FWIDTH_ULTRA_CONDENSED:    rDFA.SetWidthType(WIDTH_ULTRA_CONDENSED); break;
            case FWIDTH_EXTRA_CONDENSED:    rDFA.SetWidthType(WIDTH_EXTRA_CONDENSED); break;
            case FWIDTH_CONDENSED:          rDFA.SetWidthType(WIDTH_CONDENSED); break;
            case FWIDTH_SEMI_CONDENSED:     rDFA.SetWidthType(WIDTH_SEMI_CONDENSED); break;
            case FWIDTH_SEMI_EXPANDED:      rDFA.SetWidthType(WIDTH_SEMI_EXPANDED); break;
            case FWIDTH_EXPANDED:           rDFA.SetWidthType(WIDTH_EXPANDED); break;
            case FWIDTH_EXTRA_EXPANDED:     rDFA.SetWidthType(WIDTH_EXTRA_EXPANDED); break;
            case FWIDTH_ULTRA_EXPANDED:     rDFA.SetWidthType(WIDTH_ULTRA_EXPANDED); break;

            case FWIDTH_NORMAL:
            default:                        rFont.m_eWidth = WIDTH_NORMAL; break;
            default:                        rDFA.SetWidthType(WIDTH_NORMAL); break;
        }

        rFont.m_ePitch = aInfo.pitch ? PITCH_FIXED : PITCH_VARIABLE;
        rFont.m_eItalic = aInfo.italicAngle == 0 ? ITALIC_NONE : ( aInfo.italicAngle < 0 ? ITALIC_NORMAL : ITALIC_OBLIQUE );
        rDFA.SetPitch(aInfo.pitch ? PITCH_FIXED : PITCH_VARIABLE);
        rDFA.SetItalic(aInfo.italicAngle == 0 ? ITALIC_NONE : (aInfo.italicAngle < 0 ? ITALIC_NORMAL : ITALIC_OBLIQUE));
        // #104264# there are fonts that set italic angle 0 although they are
        // italic; use macstyle bit here
        if( aInfo.italicAngle == 0 && (aInfo.macStyle & 2) )
            rFont.m_eItalic = ITALIC_NORMAL;
            rDFA.SetItalic(ITALIC_NORMAL);

        rFont.m_aEncoding = aInfo.microsoftSymbolEncoded ? RTL_TEXTENCODING_SYMBOL : RTL_TEXTENCODING_UCS2;
        rDFA.SetMicrosoftSymbolEncoded(aInfo.microsoftSymbolEncoded);

        CloseTTFont( pTTFont );
        bSuccess = true;
@@ -675,29 +672,6 @@ void PrintFontManager::getFontList( ::std::vector< fontID >& rFontIDs )
        rFontIDs.push_back(font.first);
}

void PrintFontManager::fillPrintFontInfo(const PrintFont& rFont, FastPrintFontInfo& rInfo)
{
    rInfo.m_aFamilyName     = rFont.m_aFamilyName;
    rInfo.m_aStyleName      = rFont.m_aStyleName;
    rInfo.m_eFamilyStyle    = rFont.m_eFamilyStyle;
    rInfo.m_eItalic         = rFont.m_eItalic;
    rInfo.m_eWidth          = rFont.m_eWidth;
    rInfo.m_eWeight         = rFont.m_eWeight;
    rInfo.m_ePitch          = rFont.m_ePitch;
    rInfo.m_aEncoding       = rFont.m_aEncoding;
}

bool PrintFontManager::getFontFastInfo( fontID nFontID, FastPrintFontInfo& rInfo ) const
{
    const PrintFont* pFont = getFont( nFontID );
    if( pFont )
    {
        rInfo.m_nID = nFontID;
        fillPrintFontInfo( *pFont, rInfo );
    }
    return pFont != nullptr;
}

int PrintFontManager::getFontFaceNumber( fontID nFontID ) const
{
    int nRet = 0;
diff --git a/vcl/unx/generic/gdi/freetypetextrender.cxx b/vcl/unx/generic/gdi/freetypetextrender.cxx
index e8eb6c4..b524a45 100644
--- a/vcl/unx/generic/gdi/freetypetextrender.cxx
+++ b/vcl/unx/generic/gdi/freetypetextrender.cxx
@@ -28,7 +28,7 @@
#include <vcl/fontcharmap.hxx>
#include <sal/log.hxx>

#include <unx/genpspgraphics.h>
#include <unx/fontmanager.hxx>
#include <unx/geninst.h>
#include <unx/glyphcache.hxx>
#include <unx/fc_fontoptions.hxx>
@@ -103,23 +103,24 @@ bool FreeTypeTextRenderImpl::AddTempDevFont(vcl::font::PhysicalFontCollection* p
        return false;

    FreetypeManager& rFreetypeManager = FreetypeManager::get();
    for (auto const& elem : aFontIds)
    for (auto const& nFontId : aFontIds)
    {
        // prepare font data
        psp::FastPrintFontInfo aInfo;
        rMgr.getFontFastInfo(elem, aInfo);
        if (!rFontName.isEmpty())
            aInfo.m_aFamilyName = rFontName;
        auto const* pFont = rMgr.getFont(nFontId);
        if (!pFont)
            continue;

        // inform glyph cache of new font
        FontAttributes aDFA = GenPspGraphics::Info2FontAttributes(aInfo);
        FontAttributes aDFA = pFont->m_aFontAttributes;
        aDFA.IncreaseQualityBy(5800);
        if (!rFontName.isEmpty())
            aDFA.SetFamilyName(rFontName);

        int nFaceNum = rMgr.getFontFaceNumber(aInfo.m_nID);
        int nVariantNum = rMgr.getFontFaceVariation(aInfo.m_nID);
        int nFaceNum = rMgr.getFontFaceNumber(nFontId);
        int nVariantNum = rMgr.getFontFaceVariation(nFontId);

        const OString& rFileName = rMgr.getFontFileSysPath(aInfo.m_nID);
        rFreetypeManager.AddFontFile(rFileName, nFaceNum, nVariantNum, aInfo.m_nID, aDFA);
        const OString& rFileName = rMgr.getFontFileSysPath(nFontId);
        rFreetypeManager.AddFontFile(rFileName, nFaceNum, nVariantNum, nFontId, aDFA);
    }

    // announce new font to device's font list
@@ -139,22 +140,22 @@ void FreeTypeTextRenderImpl::GetDevFontList(vcl::font::PhysicalFontCollection* p

    psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
    ::std::vector<psp::fontID> aList;
    psp::FastPrintFontInfo aInfo;
    rMgr.getFontList(aList);
    for (auto const& elem : aList)
    for (auto const& nFontId : aList)
    {
        if (!rMgr.getFontFastInfo(elem, aInfo))
        auto const* pFont = rMgr.getFont(nFontId);
        if (!pFont)
            continue;

        // normalize face number to the FreetypeManager
        int nFaceNum = rMgr.getFontFaceNumber(aInfo.m_nID);
        int nVariantNum = rMgr.getFontFaceVariation(aInfo.m_nID);
        int nFaceNum = rMgr.getFontFaceNumber(nFontId);
        int nVariantNum = rMgr.getFontFaceVariation(nFontId);

        // inform FreetypeManager about this font provided by the PsPrint subsystem
        FontAttributes aDFA = GenPspGraphics::Info2FontAttributes(aInfo);
        FontAttributes aDFA = pFont->m_aFontAttributes;
        aDFA.IncreaseQualityBy(4096);
        const OString& rFileName = rMgr.getFontFileSysPath(aInfo.m_nID);
        rFreetypeManager.AddFontFile(rFileName, nFaceNum, nVariantNum, aInfo.m_nID, aDFA);
        const OString& rFileName = rMgr.getFontFileSysPath(nFontId);
        rFreetypeManager.AddFontFile(rFileName, nFaceNum, nVariantNum, nFontId, aDFA);
    }

    // announce glyphcache fonts
diff --git a/vcl/unx/generic/print/genpspgraphics.cxx b/vcl/unx/generic/print/genpspgraphics.cxx
index 9ffc758..66bf452 100644
--- a/vcl/unx/generic/print/genpspgraphics.cxx
+++ b/vcl/unx/generic/print/genpspgraphics.cxx
@@ -138,22 +138,6 @@ std::unique_ptr<GenericSalLayout> GenPspGraphics::GetTextLayout(int nFallbackLev
    return m_aTextRenderImpl.GetTextLayout(nFallbackLevel);
}

FontAttributes GenPspGraphics::Info2FontAttributes( const psp::FastPrintFontInfo& rInfo )
{
    FontAttributes aDFA;
    aDFA.SetFamilyName( rInfo.m_aFamilyName );
    aDFA.SetStyleName( rInfo.m_aStyleName );
    aDFA.SetFamilyType( rInfo.m_eFamilyStyle );
    aDFA.SetWeight( rInfo.m_eWeight );
    aDFA.SetItalic( rInfo.m_eItalic );
    aDFA.SetWidthType( rInfo.m_eWidth );
    aDFA.SetPitch( rInfo.m_ePitch );
    aDFA.SetMicrosoftSymbolEncoded( rInfo.m_aEncoding == RTL_TEXTENCODING_SYMBOL );
    aDFA.SetQuality(512);

    return aDFA;
}

namespace vcl
{
    const char* getLangBoost()
diff --git a/vcl/unx/gtk3/salnativewidgets-gtk.cxx b/vcl/unx/gtk3/salnativewidgets-gtk.cxx
index a531a59..a3a82ed 100644
--- a/vcl/unx/gtk3/salnativewidgets-gtk.cxx
+++ b/vcl/unx/gtk3/salnativewidgets-gtk.cxx
@@ -2219,39 +2219,43 @@ vcl::Font pango_to_vcl(const PangoFontDescription* font, const css::lang::Locale
    PangoWeight    eWeight    = pango_font_description_get_weight( font );
    PangoStretch eStretch = pango_font_description_get_stretch( font );

    psp::FastPrintFontInfo aInfo;
    FontAttributes aDFA;

    // set family name
    aInfo.m_aFamilyName = OStringToOUString( aFamily, RTL_TEXTENCODING_UTF8 );
    aDFA.SetFamilyName(OStringToOUString(aFamily, RTL_TEXTENCODING_UTF8));

    // set italic
    switch( eStyle )
    {
        case PANGO_STYLE_NORMAL:    aInfo.m_eItalic = ITALIC_NONE;break;
        case PANGO_STYLE_ITALIC:    aInfo.m_eItalic = ITALIC_NORMAL;break;
        case PANGO_STYLE_OBLIQUE:    aInfo.m_eItalic = ITALIC_OBLIQUE;break;
        case PANGO_STYLE_NORMAL:    aDFA.SetItalic(ITALIC_NONE);break;
        case PANGO_STYLE_ITALIC:    aDFA.SetItalic(ITALIC_NORMAL);break;
        case PANGO_STYLE_OBLIQUE:    aDFA.SetItalic(ITALIC_OBLIQUE);break;
    }

    // set weight
    if( eWeight <= PANGO_WEIGHT_ULTRALIGHT )
        aInfo.m_eWeight = WEIGHT_ULTRALIGHT;
        aDFA.SetWeight(WEIGHT_ULTRALIGHT);
    else if( eWeight <= PANGO_WEIGHT_LIGHT )
        aInfo.m_eWeight = WEIGHT_LIGHT;
        aDFA.SetWeight(WEIGHT_LIGHT);
    else if( eWeight <= PANGO_WEIGHT_NORMAL )
        aInfo.m_eWeight = WEIGHT_NORMAL;
        aDFA.SetWeight(WEIGHT_NORMAL);
    else if( eWeight <= PANGO_WEIGHT_BOLD )
        aInfo.m_eWeight = WEIGHT_BOLD;
        aDFA.SetWeight(WEIGHT_BOLD);
    else
        aInfo.m_eWeight = WEIGHT_ULTRABOLD;
        aDFA.SetWeight(WEIGHT_ULTRABOLD);

    // set width
    switch( eStretch )
    {
        case PANGO_STRETCH_ULTRA_CONDENSED:    aInfo.m_eWidth = WIDTH_ULTRA_CONDENSED;break;
        case PANGO_STRETCH_EXTRA_CONDENSED:    aInfo.m_eWidth = WIDTH_EXTRA_CONDENSED;break;
        case PANGO_STRETCH_CONDENSED:        aInfo.m_eWidth = WIDTH_CONDENSED;break;
        case PANGO_STRETCH_SEMI_CONDENSED:    aInfo.m_eWidth = WIDTH_SEMI_CONDENSED;break;
        case PANGO_STRETCH_NORMAL:            aInfo.m_eWidth = WIDTH_NORMAL;break;
        case PANGO_STRETCH_SEMI_EXPANDED:    aInfo.m_eWidth = WIDTH_SEMI_EXPANDED;break;
        case PANGO_STRETCH_EXPANDED:        aInfo.m_eWidth = WIDTH_EXPANDED;break;
        case PANGO_STRETCH_EXTRA_EXPANDED:    aInfo.m_eWidth = WIDTH_EXTRA_EXPANDED;break;
        case PANGO_STRETCH_ULTRA_EXPANDED:    aInfo.m_eWidth = WIDTH_ULTRA_EXPANDED;break;
        case PANGO_STRETCH_ULTRA_CONDENSED:    aDFA.SetWidthType(WIDTH_ULTRA_CONDENSED);break;
        case PANGO_STRETCH_EXTRA_CONDENSED:    aDFA.SetWidthType(WIDTH_EXTRA_CONDENSED);break;
        case PANGO_STRETCH_CONDENSED:        aDFA.SetWidthType(WIDTH_CONDENSED);break;
        case PANGO_STRETCH_SEMI_CONDENSED:    aDFA.SetWidthType(WIDTH_SEMI_CONDENSED);break;
        case PANGO_STRETCH_NORMAL:            aDFA.SetWidthType(WIDTH_NORMAL);break;
        case PANGO_STRETCH_SEMI_EXPANDED:    aDFA.SetWidthType(WIDTH_SEMI_EXPANDED);break;
        case PANGO_STRETCH_EXPANDED:        aDFA.SetWidthType(WIDTH_EXPANDED);break;
        case PANGO_STRETCH_EXTRA_EXPANDED:    aDFA.SetWidthType(WIDTH_EXTRA_EXPANDED);break;
        case PANGO_STRETCH_ULTRA_EXPANDED:    aDFA.SetWidthType(WIDTH_ULTRA_EXPANDED);break;
    }

#if OSL_DEBUG_LEVEL > 1
@@ -2260,14 +2264,16 @@ vcl::Font pango_to_vcl(const PangoFontDescription* font, const css::lang::Locale
#endif

    // match font to e.g. resolve "Sans"
    psp::PrintFontManager::get().matchFont(aInfo, rLocale);
    bool bFound = psp::PrintFontManager::get().matchFont(aDFA, rLocale);

#if OSL_DEBUG_LEVEL > 1
    SAL_INFO("vcl.gtk3", "font match "
            << (aInfo.m_nID != 0 ? "succeeded" : "failed")
            << (bFound ? "succeeded" : "failed")
            << ", name AFTER: \""
            << aInfo.m_aFamilyName
            << aDFA.GetFamilyName()
            << "\".");
#else
    (void) bFound;
#endif

    int nPangoHeight = pango_font_description_get_size(font) / PANGO_SCALE;
@@ -2280,15 +2286,15 @@ vcl::Font pango_to_vcl(const PangoFontDescription* font, const css::lang::Locale
        nPangoHeight = nPangoHeight / nDPIY;
    }

    vcl::Font aFont(aInfo.m_aFamilyName, Size(0, nPangoHeight));
    if( aInfo.m_eWeight != WEIGHT_DONTKNOW )
        aFont.SetWeight( aInfo.m_eWeight );
    if( aInfo.m_eWidth != WIDTH_DONTKNOW )
        aFont.SetWidthType( aInfo.m_eWidth );
    if( aInfo.m_eItalic != ITALIC_DONTKNOW )
        aFont.SetItalic( aInfo.m_eItalic );
    if( aInfo.m_ePitch != PITCH_DONTKNOW )
        aFont.SetPitch( aInfo.m_ePitch );
    vcl::Font aFont(aDFA.GetFamilyName(), Size(0, nPangoHeight));
    if (aDFA.GetWeight() != WEIGHT_DONTKNOW)
        aFont.SetWeight(aDFA.GetWeight());
    if (aDFA.GetWidthType() != WIDTH_DONTKNOW)
        aFont.SetWidthType(aDFA.GetWidthType());
    if (aDFA.GetItalic() != ITALIC_DONTKNOW)
        aFont.SetItalic(aDFA.GetItalic());
    if (aDFA.GetPitch() != PITCH_DONTKNOW)
        aFont.SetPitch(aDFA.GetPitch());
    return aFont;
}